@contember/engine-server 1.2.1 → 1.3.0-alpha.2

package/src/config/config.ts

@@ -1,56 +0,0 @@
-import { ConfigLoader, createObjectParametersResolver, Merger, resolveParameters } from '@contember/config-loader'
-import { ConfigProcessor } from '@contember/engine-plugins'
-import { serverConfigSchema as defaultServerConfigSchema, tenantConfigSchema } from './configSchema'
-import { configTemplate } from './configTemplate'
-import { createProjectConfigResolver, ProjectConfigResolver } from './projectConfigResolver'
-import { createTenantConfigResolver, TenantConfigResolver } from './tenantConfigResolver'
-import { Type } from '@contember/typesafe'
-
-export type ServerConfig = ReturnType<typeof defaultServerConfigSchema>
-export type TenantConfig = ReturnType<typeof tenantConfigSchema>
-
-export type ConfigSource = { data: string; type: 'file' | 'json' | 'yaml' }
-
-type Env = Record<string, string>
-
-export async function readConfig<T extends ServerConfig>(
-	configSources: ConfigSource[] = [],
-	configProcessors: ConfigProcessor[] = [],
-	serverConfigSchema: Type<T> = defaultServerConfigSchema as Type<T>,
-): Promise<{
-	serverConfig: T
-	projectConfigResolver: ProjectConfigResolver
-	tenantConfigResolver: TenantConfigResolver
-}> {
-	const loader = new ConfigLoader()
-	const configs = await Promise.all(
-		configSources.map(it => (it.type === 'file' ? loader.load(it.data) : loader.loadString(it.data, it.type))),
-	)
-	const env: Env = {
-		...configProcessors.reduce((acc, curr) => ({ ...acc, ...(curr.getDefaultEnv?.() || {}) }), {
-			DEFAULT_DB_PORT: '5432',
-		}),
-		...Object.fromEntries(Object.entries(process.env).filter((it): it is [string, string] => it[1] !== undefined)),
-	}
-
-	const template = configProcessors.reduce(
-		(tpl, processor) => processor.prepareConfigTemplate?.(tpl, { env }) || tpl,
-		configTemplate,
-	)
-
-	const rawConfig = Merger.merge(template, ...configs)
-
-	const parametersResolver = createObjectParametersResolver({ env })
-	const config = resolveParameters(rawConfig.server, parametersResolver)
-
-	const serverConfig = serverConfigSchema(config)
-	return {
-		serverConfig,
-		projectConfigResolver: createProjectConfigResolver(env, rawConfig, configProcessors),
-		tenantConfigResolver: createTenantConfigResolver(env, rawConfig.tenant),
-	}
-}
-
-
-
-

package/src/config/configSchema.ts

@@ -1,135 +0,0 @@
-import * as Typesafe from '@contember/typesafe'
-import { MailerOptions } from '@contember/engine-tenant-api'
-import { upperCaseFirst } from '../utils'
-
-
-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({
-		read: (val: unknown) => {
-			const readDb = readDbSchema(val)
-			if ('host' in readDb) {
-				return readDb
-			}
-			return undefined
-		},
-	}),
-)
-
-export const tenantConfigSchema = Typesafe.intersection(
-	Typesafe.object({
-		db: dbConfigSchema,
-		mailer: Typesafe.transform(Typesafe.partial({
-			from: Typesafe.string,
-			host: Typesafe.string,
-			port: Typesafe.number,
-			user: Typesafe.string,
-			password: Typesafe.string,
-		}), (value, input): MailerOptions & Typesafe.JsonObject => {
-			return {
-				...(input as any),
-				...value,
-				...(value.user ? { auth: { user: value.user, pass: value.password } } : {}),
-			}
-		}),
-		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,
-		}),
-	}),
-)
-
-export const serverConfigSchema = Typesafe.object({
-	port: Typesafe.number,
-	http: Typesafe.partial({
-		requestBodySize: Typesafe.string,
-	}),
-	logging: Typesafe.union(
-		(val): { sentry?: { dsn: string } } => Typesafe.valueAt(val, ['sentry', 'dsn']) === undefined ? {} : Typesafe.fail([]),
-		Typesafe.partial({
-			sentry: Typesafe.object({
-				dsn: Typesafe.string,
-			}),
-		}),
-	),
-})
-
-export const stageConfig = Typesafe.record(
-	Typesafe.string,
-	Typesafe.intersection(
-		Typesafe.object({
-			name: Typesafe.union(
-				Typesafe.string,
-				(_: unknown, path: PropertyKey[] = []) => upperCaseFirst(String(path[path.length - 2])),
-			),
-			slug: (_: unknown, path: PropertyKey[] = []) => String(path[path.length - 2]),
-		}),
-		Typesafe.partial({
-			schema: Typesafe.string,
-		}),
-	),
-)
-
-export const projectConfigSchema = Typesafe.object({
-	name: Typesafe.union(
-		Typesafe.string,
-		(_: unknown, path: PropertyKey[] = []) => upperCaseFirst(String(path[path.length - 2])).replace(/-/g, ' '),
-	),
-	slug: (_, path = []) => String(path[path.length - 2]),
-	stages: (input, path = []) => Object.values(stageConfig(input, path)),
-	db: Typesafe.intersection(
-		Typesafe.union(
-			Typesafe.object({
-				useTenantDb: Typesafe.literal(true),
-			}),
-			dbConfigSchema,
-		),
-		Typesafe.partial({
-			systemSchema: Typesafe.string,
-		}),
-	),
-})

package/src/config/configTemplate.ts

@@ -1,86 +0,0 @@
-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: {
-			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%`,
-			...createDbConfigTemplate('tenant.env.DB'),
-		},
-		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%',
-			rootTokenHash: '%?env.CONTEMBER_ROOT_TOKEN_HASH%',
-			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%`,
-			database: `%?project.env.DB_NAME||project.slug%`,
-			...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'),
-			},
-		},
-	},
-	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%',
-			configHeader: '%?env.CONTEMBER_PROJECT_GROUP_CONFIG_HEADER%',
-			configEncryptionKey: '%?env.CONTEMBER_PROJECT_GROUP_CONFIG_ENCRYPTION_KEY%',
-		},
-		logging: {
-			sentry: {
-				dsn: '%?env.SENTRY_DSN%',
-			},
-		},
-	},
-}

package/src/config/projectConfigResolver.ts

@@ -1,86 +0,0 @@
-import { ProjectConfig, ProjectSecrets } from '@contember/engine-http'
-import { ConfigProcessor } from '@contember/engine-plugins'
-import { Merger, ParametersResolver, resolveParameters, UndefinedParameterError } from '@contember/config-loader'
-import * as Typesafe from '@contember/typesafe'
-import { projectConfigSchema } from './configSchema'
-import { TenantConfig } from './config'
-
-export type ProjectConfigResolver = (
-	slug: string,
-	additionalConfig: any,
-	secrets: ProjectSecrets,
-	tenantConfig: TenantConfig,
-) => ProjectConfig
-
-type Env = Record<string, string>
-
-export const createProjectConfigResolver = (env: Env, config: any, configProcessors: ConfigProcessor[]): ProjectConfigResolver =>
-	(slug, additionalConfig, secrets, tenantConfig): ProjectConfig => {
-		const mergedConfig = Merger.merge(
-			config.projectDefaults as any,
-			(config?.projects as any)?.[slug] as any,
-			additionalConfig,
-		)
-		if (!mergedConfig.stages) {
-			mergedConfig.stages = { live: {} }
-		}
-		const resolvedConfig = resolveParameters(mergedConfig, createProjectParametersResolver(slug, env, secrets))
-
-		const projectConfigSchemaWithPlugins = configProcessors.reduce(
-			(schema, current) => {
-				if (!current.getProjectConfigSchema) {
-					return schema
-				}
-				return Typesafe.intersection(schema, current.getProjectConfigSchema(slug))
-			},
-			projectConfigSchema,
-		)
-		const projectConfig = projectConfigSchemaWithPlugins(resolvedConfig, ['project', slug])
-		if (!('host' in projectConfig.db)) {
-			return {
-				...projectConfig,
-				db: {
-					...tenantConfig.db,
-					...projectConfig.db,
-				},
-			}
-		}
-		return {
-			...projectConfig,
-			db: projectConfig.db,
-		}
-	}
-
-
-const createProjectParametersResolver = (slug: string, env: Env, secrets: ProjectSecrets): ParametersResolver =>
-	parts => {
-		if (parts[0] === 'project') {
-			if (parts[1] === 'env') {
-				const envName = parts[2]
-				const projectEnvName = projectNameToEnvName(slug)
-				const envValue = env[projectEnvName + '_' + envName] || env['DEFAULT_' + envName]
-				if (envValue === undefined) {
-					throw new UndefinedParameterError(`ENV variable "${projectEnvName + '_' + envName}" not found.`)
-				}
-				return envValue
-			} else if (parts[1] === 'slug') {
-				return slug
-			} else if (parts[1] === 'secret') {
-				const key = parts.slice(2).join('.')
-				const value = secrets[key]
-				if (value === undefined) {
-					throw new UndefinedParameterError(`Project secret ${parts[2]} not found`)
-				}
-				return value
-			}
-		}
-		throw new UndefinedParameterError(`Parameter "${parts.join('.')}" not found.`)
-	}
-
-const projectNameToEnvName = (projectName: string): string => {
-	const envName = projectName.toUpperCase().replace(/-/g, '_')
-	if (envName === 'TENANT') {
-		throw new Error('Forbidden project name')
-	}
-	return envName
-}

package/src/config/tenantConfigResolver.ts

@@ -1,41 +0,0 @@
-import { TenantConfig } from './config'
-import {
-	createObjectParametersResolver,
-	Merger,
-	ParametersResolver,
-	resolveParameters,
-	UndefinedParameterError,
-} from '@contember/config-loader'
-import { tenantConfigSchema } from './configSchema'
-
-export type TenantConfigResolver =  (slug: string | undefined, additionalConfig: any) => TenantConfig
-
-type Env = Record<string, string>
-
-export const createTenantConfigResolver = (env: Env, tenantConfig: any): TenantConfigResolver =>
-	(slug, additionalConfig) => {
-		const mergedConfig = Merger.merge(tenantConfig, additionalConfig)
-		const parametersResolver = createObjectParametersResolver({ env })
-		const tenantParametersResolver = createTenantParametersResolver(env)
-		const resolvedConfig = resolveParameters(mergedConfig, (parts, path, dataResolver) => {
-			if (parts[0] === 'tenant') {
-				return tenantParametersResolver(parts, path, dataResolver)
-			}
-			return parametersResolver(parts, path, dataResolver)
-		})
-		return tenantConfigSchema(resolvedConfig)
-	}
-
-
-export const createTenantParametersResolver = (env: Env): ParametersResolver =>
-	parts => {
-		if (parts[1] === 'env') {
-			const envName = parts[2]
-			const envValue = env['TENANT_' + envName] || env['DEFAULT_' + envName]
-			if (envValue === undefined) {
-				throw new UndefinedParameterError(`ENV variable "${'TENANT_' + envName}" not found.`)
-			}
-			return envValue
-		}
-		throw new UndefinedParameterError(`Parameter "${parts.join('.')}" not found.`)
-	}

package/src/index.ts

@@ -1,23 +0,0 @@
-import { MasterContainerFactory, MasterContainerArgs } from './MasterContainer'
-import { ProjectConfig } from '@contember/engine-http'
-import { readConfig } from './config/config'
-import { serverConfigSchema } from './config/configSchema'
-import { TenantConfigResolver } from './config/tenantConfigResolver'
-import { ProjectGroupContainerFactory } from './projectGroup/ProjectGroupContainer'
-
-export * from './utils/serverStartup'
-export * from './utils/serverTermination'
-export * from './utils/sentry'
-export * from './MasterContainer'
-
-export {
-	ProjectConfig,
-	readConfig,
-	serverConfigSchema,
-	TenantConfigResolver,
-	ProjectGroupContainerFactory,
-}
-
-export const createContainer = (args: MasterContainerArgs) => {
-	return new MasterContainerFactory().create(args)
-}

package/src/project/ProjectContainer.ts

@@ -1,95 +0,0 @@
-import { Builder } from '@contember/dic'
-import { Connection } from '@contember/database'
-import { DatabaseContextFactory, SchemaVersionBuilder } from '@contember/engine-system-api'
-import { GraphQlSchemaBuilderFactory, PermissionsByIdentityFactory } from '@contember/engine-content-api'
-import { GraphQLSchemaContributor, Plugin } from '@contember/engine-plugins'
-import {
-	ContentSchemaResolver,
-	GraphQlSchemaFactory,
-	ProjectConfig,
-	ProjectContainer,
-	Providers,
-} from '@contember/engine-http'
-import { Logger } from '@contember/logger'
-
-export class ProjectContainerFactoryFactory {
-	constructor(
-		private readonly debug: boolean,
-		private readonly plugins: Plugin[],
-		private readonly providers: Providers,
-	) {
-	}
-
-	create(schemaVersionBuilder: SchemaVersionBuilder, logger: Logger): ProjectContainerFactory {
-		return new ProjectContainerFactory(this.debug, this.plugins, schemaVersionBuilder, this.providers, logger)
-	}
-}
-
-interface ProjectContainerFactoryArgs {
-	project: ProjectConfig
-}
-
-export class ProjectContainerFactory {
-	constructor(
-		private readonly debug: boolean,
-		private readonly plugins: Plugin[],
-		private readonly schemaVersionBuilder: SchemaVersionBuilder,
-		private readonly providers: Providers,
-		private readonly logger: Logger,
-	) {}
-
-	public createContainer(args: ProjectContainerFactoryArgs): ProjectContainer {
-		return this.createBuilder(args)
-			.build()
-			.pick(
-				'project',
-				'connection',
-				'readConnection',
-				'systemDatabaseContextFactory',
-				'contentSchemaResolver',
-				'graphQlSchemaFactory',
-				'logger',
-			)
-	}
-
-	protected createBuilder({ project }: ProjectContainerFactoryArgs) {
-		return new Builder({})
-			.addService('providers', () =>
-				this.providers)
-			.addService('schemaVersionBuilder', () =>
-				this.schemaVersionBuilder)
-			.addService('logger', () =>
-				this.logger.child({ project: project.slug }))
-			.addService('project', () =>
-				project)
-			.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', ({}) =>
-				new PermissionsByIdentityFactory())
-			.addService('graphQlSchemaFactory', ({ project, permissionsByIdentityFactory, graphQlSchemaBuilderFactory, providers }) => {
-				const contributors = this.plugins
-					.map(it => (it.getSchemaContributor ? it.getSchemaContributor({ project, providers }) : null))
-					.filter((it): it is GraphQLSchemaContributor => !!it)
-				return new GraphQlSchemaFactory(graphQlSchemaBuilderFactory, permissionsByIdentityFactory, contributors)
-			})
-			.addService('contentSchemaResolver', ({ schemaVersionBuilder }) =>
-				new ContentSchemaResolver(schemaVersionBuilder))
-			.addService('systemDatabaseContextFactory', ({ connection, providers, project }) =>
-				new DatabaseContextFactory(connection.createClient(project.db.systemSchema ?? 'system', { module: 'system' }), providers))
-	}
-}

package/src/project/ProjectContainerResolver.ts

@@ -1,87 +0,0 @@
-import { ProjectContainerFactory } from './ProjectContainer'
-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 { ProjectConfigResolver } from '../config/projectConfigResolver'
-import { TenantConfig } from '../config/config'
-import { Logger } from '@contember/logger'
-
-export class ProjectContainerResolver {
-	private projectContainers = new ProjectContainerStore()
-
-	public readonly onCreate: ((container: ProjectContainer) => void | (() => void))[] = []
-
-	constructor(
-		private readonly projectContainerFactory: ProjectContainerFactory,
-		private readonly projectConfigResolver: ProjectConfigResolver,
-		private readonly projectManager: ProjectManager,
-		private readonly systemProjectInitializer: SystemProjectInitializer,
-		private readonly tenantDatabase: DatabaseContext,
-		private readonly tenantConfig: TenantConfig,
-	) {}
-
-
-	public async getProjectContainer(slug: string, { alias = false }: { alias?: boolean } = {}): Promise<ProjectContainer | undefined> {
-		const realSlug = this.projectContainers.resolveAlias(slug)
-		if (realSlug) {
-			slug = realSlug
-		}
-		const existing = this.projectContainers.getContainer(slug)
-		if (existing) {
-			const existingAwaited = await existing
-			const state = await this.projectManager.getProjectState(this.tenantDatabase, slug, existingAwaited.timestamp)
-			if (state === 'valid') {
-				return (await existingAwaited).container
-			}
-			await this.destroyContainer(slug)
-			if (state === 'not_found') {
-				return undefined
-			}
-		}
-		const project = await this.projectManager.getProjectWithSecretsBySlug(this.tenantDatabase, slug, alias)
-		if (!project) {
-			return undefined
-		}
-		const container = await this.createProjectContainer(project)
-		if (slug !== project.slug) {
-			this.projectContainers.setAlias(project.slug, slug)
-		}
-		return container
-	}
-
-	public async createProjectContainer(project: ProjectWithSecrets, logger?: Logger): 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,
-				logger ?? projectContainer.logger,
-			)
-			const cleanups = this.onCreate.map(it => it(projectContainer) || (() => null))
-			return {
-				container: projectContainer,
-				cleanups,
-				timestamp: project.updatedAt,
-			}
-		})).container
-	}
-
-	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 => this.projectContainers.removeAlias(it))
-			this.projectContainers.removeContainer(slug)
-		}
-		process.nextTick(() => {
-			if (global.gc) {
-				global.gc()
-			}
-		})
-	}
-}

package/src/project/ProjectContainerStore.ts

@@ -1,33 +0,0 @@
-import { ProjectContainer } from '@contember/engine-http'
-import { PromiseMap } from '@contember/engine-common'
-
-type ContainerWithMeta = { container: ProjectContainer; cleanups: (() => void)[]; timestamp: Date }
-
-export class ProjectContainerStore {
-	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)
-	}
-}

package/src/project/ProjectInitializer.ts

@@ -1,28 +0,0 @@
-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, logger: Logger) {
-		await this.projectContainerResolver.createProjectContainer(project)
-	}
-}
-
-export class ProjectInitializerProxy implements ProjectInitializerInterface {
-	private initializer: ProjectInitializerInterface | undefined = undefined
-
-	setInitializer(initializer: ProjectInitializerInterface): void {
-		this.initializer = initializer
-	}
-
-	initializeProject(project: ProjectWithSecrets, logger: Logger) {
-		if (!this.initializer) {
-			throw new Error('Initializer is not set')
-		}
-		return this.initializer.initializeProject(project, logger)
-	}
-}