@contember/engine-server 0.12.0-alpha.9 → 1.0.0-alpha.0

package/src/config/config.ts

@@ -5,244 +5,167 @@ import {
 	resolveParameters,
 	UndefinedParameterError,
 } from '@contember/config-loader'
-import { DatabaseCredentials } from '@contember/database'
-import { tuple, upperCaseFirst } from '../utils'
-import { MailerOptions, TenantCredentials } from '@contember/engine-tenant-api'
+import { upperCaseFirst } from '../utils'
 import { ConfigProcessor } from '@contember/engine-plugins'
-import {
-	isObject,
-	typeConfigError,
-	hasStringProperty,
-	hasNumberProperty,
-	hasBooleanProperty,
-} from '@contember/engine-common'
-import { ProjectConfig, ProjectConfigResolver, StageConfig } from '@contember/engine-http'
+import { Typesafe } from '@contember/engine-common'
+import { ProjectConfigResolver } from '@contember/engine-http'
+import { MailerOptions } from '@contember/engine-tenant-api'
 
-export interface TenantConfig {
-	db: DatabaseCredentials
-	mailer: MailerOptions
-	credentials: TenantCredentials
-	secrets?: {
-		encryptionKey: string
-	}
-}
+export type Config = ReturnType<typeof configSchema>
+export type TenantConfig = Config['tenant']
 
-export interface Config {
-	tenant: TenantConfig
-	server: {
-		port: number
-		monitoringPort: number
-		workerCount?: number | string
-		http: {
-			requestBodySize?: string
-		}
-		logging: {
-			sentry?: {
-				dsn: string
-			}
-		}
-	}
-}
+const dbCredentialsSchema = Typesafe.intersection(
+	Typesafe.object({
+		host: Typesafe.string,
+		port: Typesafe.number,
+		user: Typesafe.string,
+		password: Typesafe.string,
+		database: Typesafe.string,
+	}),
+	Typesafe.partial({
+		ssl: Typesafe.boolean,
+	}),
+)
 
-function checkDatabaseCredentials(json: unknown, path: string): DatabaseCredentials {
-	if (!isObject(json)) {
-		return typeConfigError(path, json, 'object')
-	}
-	if (!hasStringProperty(json, 'host')) {
-		return typeConfigError(path + '.host', json.host, 'string')
-	}
-	if (!hasNumberProperty(json, 'port')) {
-		return typeConfigError(path + '.port', json.port, 'number')
-	}
-	if (!hasStringProperty(json, 'user')) {
-		return typeConfigError(path + '.user', json.user, 'string')
-	}
-	if (!hasStringProperty(json, 'password')) {
-		return typeConfigError(path + '.password', json.password, 'string')
-	}
-	if (!hasStringProperty(json, 'database')) {
-		return typeConfigError(path + '.database', json.database, 'string')
-	}
-	if (json.ssl !== undefined && !hasBooleanProperty(json, 'ssl')) {
-		return typeConfigError(path + '.ssl', json.ssl, 'boolean')
-	}
-	return json
-}
-
-function checkMailerParameters(json: unknown, path: string): MailerOptions {
-	if (!isObject(json)) {
-		return typeConfigError(path, json, 'object')
-	}
-	const values = Object.fromEntries(Object.entries(json).filter(([, it]) => it !== undefined))
-	if ('from' in values && !hasStringProperty(values, 'from')) {
-		return typeConfigError(path + '.from', values.from, 'string')
-	}
-	if ('host' in values && !hasStringProperty(values, 'host')) {
-		return typeConfigError(path + '.host', values.host, 'string')
-	}
-	if ('port' in values && !hasNumberProperty(values, 'port')) {
-		return typeConfigError(path + '.port', values.port, 'number')
-	}
-	if ('user' in values && !hasStringProperty(json, 'user')) {
-		return typeConfigError(path + '.user', json.user, 'string')
-	}
-	if ('password' in values && !hasStringProperty(json, 'password')) {
-		return typeConfigError(path + '.password', json.password, 'string')
-	}
-	return {
-		...values,
-		...('user' in values && 'password' in values
-			? { auth: { user: String(values.user), pass: String(values.password) } }
-			: {}),
-	}
-}
-
-function checkTenantCredentials(json: unknown, path: string): TenantCredentials {
-	if (!isObject(json)) {
-		return typeConfigError(path, json, 'object')
-	}
-	const values = Object.fromEntries(Object.entries(json).filter(([, it]) => it !== undefined))
-	if ('rootToken' in values && !hasStringProperty(values, 'rootToken')) {
-		return typeConfigError(path + '.rootToken', values.rootToken, 'string')
-	}
-	if ('rootPassword' in values && !hasStringProperty(values, 'rootPassword')) {
-		return typeConfigError(path + '.rootPassword', values.rootPassword, 'string')
-	}
-	if ('rootEmail' in values && !hasStringProperty(values, 'rootEmail')) {
-		return typeConfigError(path + '.rootEmail', values.rootEmail, 'string')
-	}
-	if ('loginToken' in values && !hasStringProperty(values, 'loginToken')) {
-		return typeConfigError(path + '.loginToken', values.loginToken, 'string')
-	}
-
-	return values
-}
-
-function checkTenantSecrets(json: unknown, path: string): TenantConfig['secrets'] {
-	if (!isObject(json)) {
-		return typeConfigError(path, json, 'object')
-	}
-	if (json.encryptionKey === undefined) {
-		return undefined
-	}
-	if (!hasStringProperty(json, 'encryptionKey')) {
-		return typeConfigError(path + '.encryptionKey', json.encryptionKey, 'string')
-	}
-	return {
-		encryptionKey: json.encryptionKey,
-	}
-}
-function checkTenantStructure(json: unknown): Config['tenant'] {
-	if (!isObject(json)) {
-		return typeConfigError('tenant', json, 'object')
-	}
-	return {
-		db: checkDatabaseCredentials(json.db, 'tenant.db'),
-		mailer: checkMailerParameters(json.mailer, 'tenant.mailer'),
-		credentials: checkTenantCredentials(json.credentials, 'tenant.credentials'),
-		secrets: checkTenantSecrets(json.secrets, 'tenant.secrets'),
-	}
-}
-
-function checkStageStructure(json: unknown, slug: string, path: string): StageConfig {
-	json = json || {}
-	if (!isObject(json)) {
-		return typeConfigError(path, json, 'object')
-	}
-
-	if (json.name && !hasStringProperty(json, 'name')) {
-		return typeConfigError(path + '.name', json.name, 'string')
-	}
-	return { name: upperCaseFirst(slug), ...json, slug }
-}
-
-function checkProjectStructure(json: unknown, slug: string, path: string): ProjectConfig {
-	if (!isObject(json)) {
-		return typeConfigError(path, json, 'object')
-	}
-
-	if (json.name && !hasStringProperty(json, 'name')) {
-		return typeConfigError(path + '.name', json.name, 'string')
-	}
-	if (!isObject(json.stages)) {
-		return typeConfigError(`${path}.stages`, json.stages, 'object')
-	}
-	const stages = Object.entries(json.stages).map(([slug, value]) =>
-		checkStageStructure(value, slug, `${path}.stages.${slug}`),
-	)
-	return {
-		name: upperCaseFirst(slug).replace(/-/g, ' '),
-		directory: `${slug}/api`,
-		...json,
-		slug,
-		stages: stages,
-		db: checkDatabaseCredentials(json.db, `${path}.db`),
-	}
-}
-
-function checkServerStructure(json: unknown): Config['server'] {
-	if (!isObject(json)) {
-		return typeConfigError('server', json, 'object')
-	}
-	if (!hasNumberProperty(json, 'port')) {
-		return typeConfigError('server.port', json.port, 'number')
-	}
-	if (!hasNumberProperty(json, 'monitoringPort')) {
-		return typeConfigError('server.monitoringPort', json.monitoringPort, 'number')
-	}
-	return {
-		...json,
-		logging: checkLoggingStructure(json.logging),
-		http: checkHttpStructure(json.http),
-	}
-}
-
-function checkLoggingStructure(json: unknown): Config['server']['logging'] {
-	if (!json) {
-		return {}
-	}
-	if (!isObject(json)) {
-		return typeConfigError('logging', json, 'object')
-	}
-	let sentry: Config['server']['logging']['sentry'] = undefined
-	if (json.sentry) {
-		if (!isObject(json.sentry)) {
-			return typeConfigError('logging.sentry', json.sentry, 'object')
-		}
-		if (json.sentry.dsn) {
-			if (!hasStringProperty(json.sentry, 'dsn')) {
-				return typeConfigError('logging.sentry.dsn', json.sentry.dsn, 'string')
+const tenantConfigSchema = Typesafe.intersection(
+	Typesafe.object({
+		db: dbCredentialsSchema,
+		mailer: Typesafe.transform(Typesafe.partial({
+			from: Typesafe.string,
+			host: Typesafe.string,
+			port: Typesafe.number,
+			user: Typesafe.string,
+			password: Typesafe.string,
+		}), (value, input): MailerOptions => {
+			return {
+				...(input as MailerOptions),
+				...value,
+				...(value.user ? { auth: { user: value.user, pass: value.password } } : {}),
 			}
-			sentry = { dsn: json.sentry.dsn }
-		}
-	}
+		}),
+		credentials: Typesafe.partial({
+			rootToken: Typesafe.string,
+			rootTokenHash: Typesafe.string,
+			rootPassword: Typesafe.string,
+			rootEmail: Typesafe.string,
+			loginToken: Typesafe.string,
+		}),
+	}),
+	Typesafe.object({
+		secrets: Typesafe.partial({
+			encryptionKey: Typesafe.string,
+		}),
+	}),
+)
+const serverConfigSchema = Typesafe.intersection(
+	Typesafe.object({
+		port: Typesafe.number,
+		monitoringPort: Typesafe.number,
+		http: Typesafe.partial({
+			requestBodySize: Typesafe.string,
+		}),
+		logging: Typesafe.union(
+			val => Typesafe.valueAt(val, ['sentry', 'dsn']) === undefined ? {} : Typesafe.fail([]),
+			Typesafe.partial({
+				sentry: Typesafe.object({
+					dsn: Typesafe.string,
+				}),
+			}),
+		),
+	}),
+	Typesafe.partial({
+		workerCount: Typesafe.union(Typesafe.number, Typesafe.string),
+		projectGroup: (val, path) => Typesafe.valueAt(val, ['domainMapping']) === undefined ? undefined : Typesafe.object({
+			domainMapping: Typesafe.string,
+		})(val, path),
+	}),
+)
+const configSchema = Typesafe.object({
+	tenant: tenantConfigSchema,
+	server: serverConfigSchema,
+})
 
-	return { sentry }
-}
+const stageConfig = Typesafe.map(Typesafe.object({
+	name: Typesafe.union(
+		Typesafe.string,
+		(_, path = []) => upperCaseFirst(String(path[path.length - 2])),
+	),
+	slug: (_, path = []) => String(path[path.length - 2]),
+}))
 
-function checkHttpStructure(json: unknown): Config['server']['http'] {
-	if (!json) {
-		return {}
-	}
-	if (!isObject(json)) {
-		return typeConfigError('http', json, 'object')
-	}
-	return json
-}
+const projectConfigSchema = Typesafe.object({
+	name: Typesafe.union(
+		Typesafe.string,
+		(_, path = []) => upperCaseFirst(String(path[path.length - 2])).replace(/-/g, ' '),
+	),
+	slug: (_, path = []) => String(path[path.length - 2]),
+	stages: (input, path = []) => Object.values(stageConfig(input, path)),
+	db: dbCredentialsSchema,
+})
 
-function checkConfigStructure(json: unknown): Config {
-	if (!isObject(json)) {
-		return typeConfigError('', json, 'object')
-	}
-	return {
-		...json,
-		tenant: checkTenantStructure(json.tenant),
-		server: checkServerStructure(json.server),
-	}
+const defaultTemplate: any = {
+	tenant: {
+		db: {
+			host: `%tenant.env.DB_HOST%`,
+			port: `%tenant.env.DB_PORT::number%`,
+			user: `%tenant.env.DB_USER%`,
+			password: `%tenant.env.DB_PASSWORD%`,
+			database: `%tenant.env.DB_NAME%`,
+			ssl: `%?tenant.env.DB_SSL::bool%`,
+		},
+		mailer: {
+			from: '%?tenant.env.MAILER_FROM%',
+			host: '%?tenant.env.MAILER_HOST::string%',
+			port: '%?tenant.env.MAILER_PORT::number%',
+			secure: '%?tenant.env.MAILER_SECURE::bool%',
+			user: '%?tenant.env.MAILER_USER%',
+			password: '%?tenant.env.MAILER_PASSWORD%',
+		},
+		credentials: {
+			rootEmail: '%?env.CONTEMBER_ROOT_EMAIL%',
+			rootToken: '%?env.CONTEMBER_ROOT_TOKEN%',
+			rootPassword: '%?env.CONTEMBER_ROOT_PASSWORD%',
+			loginToken: '%?env.CONTEMBER_LOGIN_TOKEN%',
+		},
+		secrets: {
+			encryptionKey: '%?env.CONTEMBER_ENCRYPTION_KEY%',
+		},
+	},
+	projectDefaults: {
+		db: {
+			host: `%project.env.DB_HOST%`,
+			port: `%project.env.DB_PORT::number%`,
+			user: `%project.env.DB_USER%`,
+			password: `%project.secret.db.password||project.env.DB_PASSWORD%`,
+			ssl: `%?project.env.DB_SSL::bool%`,
+			database: `%project.env.DB_NAME||project.slug%`,
+		},
+	},
+	server: {
+		port: '%env.CONTEMBER_PORT::number%',
+		monitoringPort: '%env.CONTEMBER_MONITORING_PORT::number%',
+		workerCount: '%?env.CONTEMBER_WORKER_COUNT::string%',
+		http: {
+			requestBodySize: '%?env.CONTEMBER_HTTP_REQUEST_BODY_SIZE::string%',
+		},
+		projectGroup: {
+			domainMapping: '%?env.CONTEMBER_PROJECT_GROUP_DOMAIN_MAPPING%',
+		},
+		logging: {
+			sentry: {
+				dsn: '%?env.SENTRY_DSN%',
+			},
+		},
+	},
 }
 
+
 const projectNameToEnvName = (projectName: string): string => {
-	return projectName.toUpperCase().replace(/-/g, '_')
+	const envName = projectName.toUpperCase().replace(/-/g, '_')
+	if (envName === 'TENANT') {
+		throw new Error('Forbidden project name')
+	}
+	return envName
 }
 
 export type ConfigSource = { data: string; type: 'file' | 'json' | 'yaml' }
@@ -265,59 +188,6 @@ export async function readConfig(
 		...Object.fromEntries(Object.entries(process.env).filter((it): it is [string, string] => it[1] !== undefined)),
 	}
 
-	const defaultTemplate: any = {
-		tenant: {
-			db: {
-				host: `%tenant.env.DB_HOST%`,
-				port: `%tenant.env.DB_PORT::number%`,
-				user: `%tenant.env.DB_USER%`,
-				password: `%tenant.env.DB_PASSWORD%`,
-				database: `%tenant.env.DB_NAME%`,
-				ssl: `%?tenant.env.DB_SSL::bool%`,
-			},
-			mailer: {
-				from: '%?tenant.env.MAILER_FROM%',
-				host: '%?tenant.env.MAILER_HOST::string%',
-				port: '%?tenant.env.MAILER_PORT::number%',
-				secure: '%?tenant.env.MAILER_SECURE::bool%',
-				user: '%?tenant.env.MAILER_USER%',
-				password: '%?tenant.env.MAILER_PASSWORD%',
-			},
-			credentials: {
-				rootEmail: '%?env.CONTEMBER_ROOT_EMAIL%',
-				rootToken: '%?env.CONTEMBER_ROOT_TOKEN%',
-				rootPassword: '%?env.CONTEMBER_ROOT_PASSWORD%',
-				loginToken: '%?env.CONTEMBER_LOGIN_TOKEN%',
-			},
-			secrets: {
-				encryptionKey: '%?env.CONTEMBER_ENCRYPTION_KEY%',
-			},
-		},
-		projectDefaults: {
-			db: {
-				host: `%project.env.DB_HOST%`,
-				port: `%project.env.DB_PORT::number%`,
-				user: `%project.env.DB_USER%`,
-				password: `%project.secret.db.password||project.env.DB_PASSWORD%`,
-				ssl: `%?project.env.DB_SSL::bool%`,
-				database: `%project.env.DB_NAME||project.slug%`,
-			},
-		},
-		server: {
-			port: '%env.CONTEMBER_PORT::number%',
-			monitoringPort: '%env.CONTEMBER_MONITORING_PORT::number%',
-			workerCount: '%?env.CONTEMBER_WORKER_COUNT::string%',
-			http: {
-				requestBodySize: '%?env.CONTEMBER_HTTP_REQUEST_BODY_SIZE::string%',
-			},
-			logging: {
-				sentry: {
-					dsn: '%?env.SENTRY_DSN%',
-				},
-			},
-		},
-	}
-
 	const template = configProcessors.reduce(
 		(tpl, processor) => processor.prepareConfigTemplate?.(tpl, { env }) || tpl,
 		defaultTemplate,
@@ -345,10 +215,7 @@ export async function readConfig(
 		return parametersResolver(parts, path, dataResolver)
 	})
 
-	const baseConfig = configProcessors.reduce<Config>(
-		(config, processor) => processor.processConfig?.<any>(config, { env }) || config,
-		checkConfigStructure(config),
-	)
+	const baseConfig = configSchema(config)
 	return {
 		config: baseConfig,
 		projectConfigResolver: (slug, additionalConfig, secrets) => {
@@ -358,7 +225,7 @@ export async function readConfig(
 				additionalConfig,
 			)
 			if (!mergedConfig.stages) {
-				mergedConfig.stages = { live: { base: null } }
+				mergedConfig.stages = { live: {} }
 			}
 			const resolvedConfig = resolveParameters(mergedConfig, (parts, path, dataResolver) => {
 				if (parts[0] === 'project') {
@@ -383,12 +250,15 @@ export async function readConfig(
 				}
 				throw new UndefinedParameterError(`Parameter "${parts.join('.')}" not found.`)
 			})
-			const projectConfig = checkProjectStructure(resolvedConfig, slug, 'project')
 
-			return configProcessors.reduce(
-				(config, processor) => processor.processProjectConfig?.(slug, config) ?? config,
-				projectConfig,
+			const projectConfigSchemaWithPlugins = configProcessors.reduce(
+				(schema, current) => (
+					current.getProjectConfigSchema ? Typesafe.intersection(schema, current.getProjectConfigSchema(slug)) : schema
+				),
+				projectConfigSchema,
 			)
+			const projectConfig = projectConfigSchemaWithPlugins(resolvedConfig, ['project', slug])
+			return projectConfig
 		},
 	}
 }

package/src/http/index.ts

@@ -1,3 +1,2 @@
 export * from './CollectHttpMetricsMiddelware'
-export * from './RootMiddleware'
 export * from './ShowMetricsMiddleware'

package/src/project/ProjectContainerResolver.ts

@@ -1,23 +1,28 @@
 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 { ProjectInitializer as SystemProjectInitializer } from '@contember/engine-system-api'
+import { ProjectGroupState } from './ProjectGroupState'
+import { Logger } from '@contember/engine-common'
 
 export class ProjectContainerResolver {
-	private containers = new Map<string, { container: ProjectContainer; cleanups: (() => void)[]; timestamp: Date }>()
-	private aliasMapping = new Map<string, string>()
+	private projectGroupStates = new WeakMap<ProjectGroup, ProjectGroupState>()
 
 	public readonly onCreate: ((container: ProjectContainer) => void | (() => void))[] = []
+
 	constructor(
-		private projectContainerFactory: ProjectContainerFactory,
-		private projectConfigResolver: ProjectConfigResolver,
-		private projectManager: ProjectManager,
+		private readonly projectContainerFactory: ProjectContainerFactory,
+		private readonly projectConfigResolver: ProjectConfigResolver,
+		private readonly projectManager: ProjectManager,
+		private readonly systemProjectInitializer: SystemProjectInitializer,
 	) {}
 
-	public async getAllProjectContainers(): Promise<ProjectContainer[]> {
-		const projects = await this.projectManager.getProjects()
+	public async getAllProjectContainers(projectGroup: ProjectGroup): Promise<ProjectContainer[]> {
+		const projects = await this.projectManager.getProjects(projectGroup.database)
 		return await Promise.all(
 			projects.map(async it => {
-				const container = await this.getProjectContainer(it.slug)
+				const container = await this.getProjectContainer(projectGroup, it.slug)
 				if (!container) {
 					throw new Error('should not happen')
 				}
@@ -26,55 +31,64 @@ export class ProjectContainerResolver {
 		)
 	}
 
-	public async getProjectContainer(slug: string, alias: boolean = false): Promise<ProjectContainer | undefined> {
-		const realSlug = this.aliasMapping.get(slug)
+	public async getProjectContainer(projectGroup: ProjectGroup, slug: string, alias: boolean = false): Promise<ProjectContainer | undefined> {
+		let groupState = this.getProjectGroupState(projectGroup)
+
+		const realSlug = groupState.resolveAlias(slug)
 		if (realSlug) {
 			slug = realSlug
 		}
-		const existing = this.containers.get(slug)
+		const existing = groupState.getContainer(slug)
 		if (existing) {
-			const state = await this.projectManager.getProjectState(slug, existing.timestamp)
+			const existingAwaited = await existing
+			const state = await this.projectManager.getProjectState(projectGroup.database, slug, existingAwaited.timestamp)
 			if (state === 'valid') {
-				return existing.container
+				return (await existingAwaited).container
 			}
-			this.destroyContainer(slug)
+			await this.destroyContainer(projectGroup, slug)
 			if (state === 'not_found') {
 				return undefined
 			}
 		}
-		const project = await this.projectManager.getProjectWithSecretsBySlug(slug, alias)
+		const project = await this.projectManager.getProjectWithSecretsBySlug(projectGroup.database, slug, alias)
 		if (!project) {
 			return undefined
 		}
-		const container = this.createProjectContainer(project)
+		const container = await this.createProjectContainer(projectGroup, project)
 		if (slug !== project.slug) {
-			this.aliasMapping.set(slug, project.slug)
+			groupState.setAlias(project.slug, slug)
 		}
 		return container
 	}
 
-	public createProjectContainer(project: ProjectWithSecrets): ProjectContainer {
+	public async createProjectContainer(projectGroup: ProjectGroup, project: ProjectWithSecrets): Promise<ProjectContainer> {
 		const projectConfig = this.projectConfigResolver(project.slug, project.config, project.secrets)
-		const existing = this.containers.get(project.slug)
-		if (existing) {
-			return existing.container
-		}
-		const projectContainer = this.projectContainerFactory.createContainer(projectConfig)
-		const cleanups = this.onCreate.map(it => it(projectContainer) || (() => null))
-		this.containers.set(project.slug, {
-			container: projectContainer,
-			cleanups,
-			timestamp: project.updatedAt,
-		})
-		return projectContainer
+		const groupState = this.getProjectGroupState(projectGroup)
+		return (await groupState.fetchContainer(project.slug, async slug => {
+			const projectContainer = this.projectContainerFactory.createContainer(projectConfig)
+			await this.systemProjectInitializer.initialize(
+				projectContainer.systemDatabaseContextFactory,
+				projectContainer.project,
+				// eslint-disable-next-line no-console
+				new Logger(console.log),
+			)
+			const cleanups = this.onCreate.map(it => it(projectContainer) || (() => null))
+			return {
+				container: projectContainer,
+				cleanups,
+				timestamp: project.updatedAt,
+			}
+		})).container
 	}
 
-	public destroyContainer(slug: string): void {
-		const existing = this.containers.get(slug)
+	public async destroyContainer(projectGroup: ProjectGroup, slug: string): Promise<void> {
+		const groupState = this.getProjectGroupState(projectGroup)
+		const existing = groupState.getContainer(slug)
 		if (existing) {
-			existing.cleanups.forEach(it => it())
-			existing.container.project.alias?.forEach(it => this.aliasMapping.delete(it))
-			this.containers.delete(slug)
+			const existingAwaited = await existing
+			existingAwaited.cleanups.forEach(it => it())
+			existingAwaited.container.project.alias?.forEach(it => groupState.removeAlias(it))
+			groupState.removeContainer(slug)
 		}
 		process.nextTick(() => {
 			if (global.gc) {
@@ -82,4 +96,13 @@ 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

@@ -0,0 +1,33 @@
+import { ProjectContainer } from '@contember/engine-http'
+import { PromiseMap } from '@contember/engine-common'
+
+type ContainerWithMeta = { container: ProjectContainer; cleanups: (() => void)[]; timestamp: Date }
+
+export class ProjectGroupState {
+	private containers = new PromiseMap<string, ContainerWithMeta>()
+	private aliasMapping = new Map<string, string>()
+
+	public resolveAlias(slug: string): string | undefined {
+		return this.aliasMapping.get(slug)
+	}
+
+	public setAlias(slug: string, alias: string): void {
+		this.aliasMapping.set(alias, slug)
+	}
+
+	public removeAlias(alias: string): void {
+		this.aliasMapping.delete(alias)
+	}
+
+	public getContainer(slug: string): Promise<ContainerWithMeta> | undefined {
+		return this.containers.get(slug)
+	}
+
+	public async fetchContainer(slug: string, factory: (slug: string) => Promise<ContainerWithMeta>): Promise<ContainerWithMeta> {
+		return await this.containers.fetch(slug, factory)
+	}
+
+	public removeContainer(slug: string): void {
+		this.containers.delete(slug)
+	}
+}