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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-server",
-  "version": "1.1.0-alpha.1",
+  "version": "1.1.0-alpha.4",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -8,24 +8,25 @@
     "test": "uvu dist/tests/cases/ \\.js$"
   },
   "dependencies": {
-    "@contember/authorization": "^1.1.0-alpha.1",
-    "@contember/config-loader": "^1.1.0-alpha.1",
-    "@contember/database": "^1.1.0-alpha.1",
-    "@contember/database-migrations": "^1.1.0-alpha.1",
-    "@contember/dic": "^1.1.0-alpha.1",
-    "@contember/engine-common": "^1.1.0-alpha.1",
-    "@contember/engine-content-api": "^1.1.0-alpha.1",
-    "@contember/engine-http": "^1.1.0-alpha.1",
-    "@contember/engine-plugins": "^1.1.0-alpha.1",
-    "@contember/engine-s3-plugin": "^1.1.0-alpha.1",
-    "@contember/engine-system-api": "^1.1.0-alpha.1",
-    "@contember/engine-tenant-api": "^1.1.0-alpha.1",
-    "@contember/engine-vimeo-plugin": "^1.1.0-alpha.1",
-    "@contember/queryable": "^1.1.0-alpha.1",
-    "@contember/schema": "^1.1.0-alpha.1",
-    "@contember/schema-definition": "^1.1.0-alpha.1",
-    "@contember/schema-migrations": "^1.1.0-alpha.1",
-    "@contember/schema-utils": "^1.1.0-alpha.1",
+    "@contember/authorization": "^1.1.0-alpha.4",
+    "@contember/config-loader": "^1.1.0-alpha.4",
+    "@contember/database": "^1.1.0-alpha.4",
+    "@contember/database-migrations": "^1.1.0-alpha.4",
+    "@contember/dic": "^1.1.0-alpha.4",
+    "@contember/engine-common": "^1.1.0-alpha.4",
+    "@contember/engine-content-api": "^1.1.0-alpha.4",
+    "@contember/engine-http": "^1.1.0-alpha.4",
+    "@contember/engine-plugins": "^1.1.0-alpha.4",
+    "@contember/engine-s3-plugin": "^1.1.0-alpha.4",
+    "@contember/engine-system-api": "^1.1.0-alpha.4",
+    "@contember/engine-tenant-api": "^1.1.0-alpha.4",
+    "@contember/engine-vimeo-plugin": "^1.1.0-alpha.4",
+    "@contember/queryable": "^1.1.0-alpha.4",
+    "@contember/schema": "^1.1.0-alpha.4",
+    "@contember/schema-definition": "^1.1.0-alpha.4",
+    "@contember/schema-migrations": "^1.1.0-alpha.4",
+    "@contember/schema-utils": "^1.1.0-alpha.4",
+    "@koa/cors": "^3.1.0",
     "@sentry/node": "^6.8.0",
     "graphql": "^15.4.0",
     "heapdump": "^0.3.15",
@@ -36,11 +37,11 @@
     "uuid": "^8.3.1"
   },
   "devDependencies": {
-    "@contember/engine-api-tester": "^1.1.0-alpha.1",
+    "@contember/engine-api-tester": "^1.1.0-alpha.4",
     "@types/koa-compress": "^4.0.1",
     "@types/node": "^17.0.5",
     "@types/supertest": "^2.0.8",
     "supertest": "^6.0.1",
-    "uvu": "^0.5.1"
+    "uvu": "^0.5.3"
   }
 }

package/src/MasterContainer.ts

@@ -1,87 +1,74 @@
-import {
-	createMapperContainer,
-	EntitiesSelector,
-	EntitiesSelectorMapperFactory,
-	PermissionsByIdentityFactory,
-} from '@contember/engine-content-api'
 import { SystemContainerFactory } from '@contember/engine-system-api'
-import { ProjectInitializer as ProjectInitializerInterface, TenantContainerFactory } from '@contember/engine-tenant-api'
-import getSystemMigrations from '@contember/engine-system-api/migrations'
+import { TenantContainerFactory } from '@contember/engine-tenant-api'
 import { Builder } from '@contember/dic'
-import { Config } from './config/config'
+import { ServerConfig } from './config/config'
 import { createDbMetricsRegistrar, logSentryError, ProcessType } from './utils'
 import { ModificationHandlerFactory } from '@contember/schema-migrations'
 import { Initializer } from './bootstrap'
 import { Plugin } from '@contember/engine-plugins'
-import { DatabaseCredentials, MigrationsRunner } from '@contember/database-migrations'
 import { createColllectHttpMetricsMiddleware, createShowMetricsMiddleware } from './http'
 import {
-	ApiMiddlewareFactory,
-	AuthMiddlewareFactory,
 	compose,
-	ContentServerMiddlewareFactory,
+	ContentApiMiddlewareFactory,
+	ContentGraphQLContextFactory,
+	ContentQueryHandlerFactory,
 	createHomepageMiddleware,
+	createModuleInfoMiddleware,
 	createPlaygroundMiddleware,
 	createPoweredByHeaderMiddleware,
 	createProviders,
 	createTimerMiddleware,
-	ErrorFactory,
+	CryptoWrapper,
+	ErrorMiddlewareFactory,
 	Koa,
-	NotModifiedMiddlewareFactory,
-	ProjectConfigResolver,
-	ProjectGroupMiddlewareFactory,
-	ProjectMemberMiddlewareFactory,
-	ProjectResolveMiddlewareFactory,
+	NotModifiedChecker,
+	ProjectGroupResolver,
 	Providers,
-	route,
-	StageResolveMiddlewareFactory,
-	SystemGraphQLMiddlewareFactory,
-	TenantGraphQLMiddlewareFactory,
+	route, SystemApiMiddlewareFactory, SystemGraphQLContextFactory,
+	SystemGraphQLHandlerFactory, TenantApiMiddlewareFactory, TenantGraphQLContextFactory,
+	TenantGraphQLHandlerFactory,
 } from '@contember/engine-http'
 import prom from 'prom-client'
-import {
-	ProjectContainerFactory,
-	ProjectContainerResolver,
-	ProjectInitializer,
-	ProjectInitializerProxy,
-	ProjectSchemaResolver,
-	ProjectSchemaResolverProxy,
-} from './project'
-import { ClientBase } from 'pg'
+import { ProjectContainerFactoryFactory } from './project'
 import { createSecretKey } from 'crypto'
 import koaCompress from 'koa-compress'
 import bodyParser from 'koa-bodyparser'
+import { ProjectConfigResolver } from './config/projectConfigResolver'
+import { TenantConfigResolver } from './config/tenantConfigResolver'
+import { ProjectGroupContainerResolver } from './projectGroup/ProjectGroupContainerResolver'
+import { ProjectGroupContainerFactory } from './projectGroup/ProjectGroupContainer'
+import corsMiddleware from '@koa/cors'
 
 export interface MasterContainer {
 	initializer: Initializer
 	koa: Koa
 	monitoringKoa: Koa
-	projectContainerResolver: ProjectContainerResolver
-	projectInitializer: ProjectInitializerInterface
 	providers: Providers
 }
 
 export interface MasterContainerArgs {
 	debugMode: boolean
-	config: Config
+	serverConfig: ServerConfig
 	projectConfigResolver: ProjectConfigResolver
+	tenantConfigResolver: TenantConfigResolver
 	plugins: Plugin[]
 	processType: ProcessType
 	version?: string
 }
 
 export class MasterContainerFactory {
-	create({
-		config,
+	createBuilder({
+		serverConfig,
 		debugMode,
 		plugins,
 		projectConfigResolver,
+		tenantConfigResolver,
 		processType,
 		version,
-	}: MasterContainerArgs): MasterContainer {
-		const masterContainer = new Builder({})
-			.addService('config', () =>
-				config)
+	}: MasterContainerArgs) {
+		return new Builder({})
+			.addService('serverConfig', () =>
+				serverConfig)
 			.addService('debugMode', () =>
 				debugMode)
 			.addService('processType', () =>
@@ -90,66 +77,29 @@ export class MasterContainerFactory {
 				version)
 			.addService('projectConfigResolver', () =>
 				projectConfigResolver)
+			.addService('tenantConfigResolver', () =>
+				tenantConfigResolver)
 			.addService('plugins', () =>
 				plugins)
-			.addService('tenantContainerFactory', ({ config }) =>
-				new TenantContainerFactory(config.tenant.db, config.tenant.mailer, config.tenant.credentials))
-			.addService('systemContainerFactory', () =>
-				new SystemContainerFactory())
-			.addService('providers', ({ config }) => {
-				const encryptionKey = config.tenant.secrets.encryptionKey
-					? createSecretKey(Buffer.from(config.tenant.secrets.encryptionKey, 'hex'))
-					: undefined
-				return createProviders({ encryptionKey })
-			})
-			.addService('projectSchemaResolver', () =>
-				new ProjectSchemaResolverProxy())
-			.addService('projectInitializer', () =>
-				new ProjectInitializerProxy())
-			.addService('tenantContainer', ({ tenantContainerFactory, providers, projectSchemaResolver, projectInitializer }) =>
-				tenantContainerFactory.create({
-					providers,
-					projectSchemaResolver,
-					projectInitializer,
-				}))
+			.addService('providers', () =>
+				createProviders())
+			.addService('tenantContainerFactory', ({ providers }) =>
+				new TenantContainerFactory(providers))
 			.addService('modificationHandlerFactory', () =>
 				new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap))
-			.addService('permissionsByIdentityFactory', ({}) =>
-				new PermissionsByIdentityFactory())
-			.addService('entitiesSelector', ({ permissionsByIdentityFactory, providers }) => {
-				const mapperFactory: EntitiesSelectorMapperFactory = (db, schema, identityVariables, permissions) =>
-					createMapperContainer({
-						schema,
-						identityVariables,
-						permissions,
-						providers,
-					}).mapperFactory(db)
-				return new EntitiesSelector(mapperFactory, permissionsByIdentityFactory)
-			})
-			.addService('systemDbMigrationsRunnerFactory', () =>
-				(db: DatabaseCredentials, dbClient: ClientBase) =>
-					new MigrationsRunner(db, 'system', getSystemMigrations, dbClient))
-			.addService('systemContainer', ({ systemContainerFactory, entitiesSelector, modificationHandlerFactory, providers, systemDbMigrationsRunnerFactory, tenantContainer }) =>
-				systemContainerFactory.create({
-					entitiesSelector,
-					modificationHandlerFactory,
-					providers,
-					systemDbMigrationsRunnerFactory,
-					identityFetcher: tenantContainer.identityFetcher,
-				}))
-			.addService('schemaVersionBuilder', ({ systemContainer }) =>
-				systemContainer.schemaVersionBuilder)
-			.addService('projectContainerFactory', ({ debugMode, plugins, schemaVersionBuilder, providers }) =>
-				new ProjectContainerFactory(debugMode, plugins, schemaVersionBuilder, providers))
-			.addService('tenantProjectManager', ({ tenantContainer }) =>
-				tenantContainer.projectManager)
-			.addService('projectContainerResolver', ({ tenantProjectManager, projectContainerFactory, projectConfigResolver, systemContainer }) =>
-				new ProjectContainerResolver(projectContainerFactory, projectConfigResolver, tenantProjectManager, systemContainer.projectInitializer))
-			.addService('tenantGraphQlMiddlewareFactory', ({ tenantContainer }) =>
-				new TenantGraphQLMiddlewareFactory(tenantContainer.resolvers, tenantContainer.resolverContextFactory, logSentryError))
-			.addService('systemGraphQLMiddlewareFactory', ({ systemContainer, debugMode }) =>
-				new SystemGraphQLMiddlewareFactory(systemContainer.systemResolversFactory, systemContainer.resolverContextFactory, logSentryError, debugMode))
-			.addService('promRegistry', ({ projectContainerResolver, processType, tenantContainer }) => {
+			.addService('systemContainerFactory', ({ providers, modificationHandlerFactory }) =>
+				new SystemContainerFactory(providers, modificationHandlerFactory))
+			.addService('projectContainerFactoryFactory', ({ debugMode, plugins, providers }) =>
+				new ProjectContainerFactoryFactory(debugMode, plugins, providers))
+			.addService('tenantGraphQLHandlerFactory', () =>
+				new TenantGraphQLHandlerFactory(logSentryError))
+			.addService('systemGraphQLHandlerFactory', ({ debugMode }) =>
+				new SystemGraphQLHandlerFactory(logSentryError, debugMode))
+			.addService('projectGroupContainerFactory', ({ providers, systemContainerFactory, tenantContainerFactory, projectContainerFactoryFactory, projectConfigResolver, tenantGraphQLHandlerFactory, systemGraphQLHandlerFactory }) =>
+				new ProjectGroupContainerFactory(providers, systemContainerFactory, tenantContainerFactory, projectContainerFactoryFactory, projectConfigResolver, tenantGraphQLHandlerFactory, systemGraphQLHandlerFactory))
+			.addService('projectGroupContainerResolver', ({ tenantConfigResolver, projectGroupContainerFactory }) =>
+				new ProjectGroupContainerResolver(tenantConfigResolver, projectGroupContainerFactory))
+			.addService('promRegistry', ({ processType, projectGroupContainerResolver }) => {
 				if (processType === ProcessType.clusterMaster) {
 					const register = new prom.AggregatorRegistry()
 					prom.collectDefaultMetrics({ register })
@@ -158,122 +108,113 @@ export class MasterContainerFactory {
 				const register = prom.register
 				prom.collectDefaultMetrics({ register })
 				const registrar = createDbMetricsRegistrar(register)
-				registrar({ connection: tenantContainer.connection, module: 'tenant', project: 'unknown' })
-				projectContainerResolver.onCreate.push(container =>
-					registrar({
-						connection: container.connection,
-						module: 'content',
-						project: container.project.slug,
-					}),
-				)
+				projectGroupContainerResolver.onCreate.push((groupContainer, slug) => {
+					groupContainer.projectContainerResolver.onCreate.push(projectContainer =>
+						registrar({
+							connection: projectContainer.connection,
+							labels: {
+								contember_module: 'content',
+								contember_project: projectContainer.project.slug,
+								contember_project_group: slug ?? 'unknown',
+							},
+						}),
+					)
+					return registrar({
+						connection: groupContainer.tenantContainer.connection,
+						labels: {
+							contember_module: 'tenant',
+							contember_project_group: slug ?? 'unknown',
+							contember_project: 'unknown',
+						},
+					})
+				})
 				return register
 			})
-			.addService('httpErrorFactory', ({ debugMode }) =>
-				new ErrorFactory(debugMode))
-			.addService('authMiddlewareFactory', ({ tenantContainer, httpErrorFactory }) =>
-				new AuthMiddlewareFactory(tenantContainer.apiKeyManager, httpErrorFactory))
-			.addService('projectGroupMiddlewareFactory', ({ tenantContainer, httpErrorFactory }) =>
-				new ProjectGroupMiddlewareFactory(config.server.projectGroup?.domainMapping, tenantContainer.projectGroupProvider, httpErrorFactory))
-			.addService('projectResolverMiddlewareFactory', ({ projectContainerResolver, httpErrorFactory }) =>
-				new ProjectResolveMiddlewareFactory(projectContainerResolver, httpErrorFactory))
-			.addService('apiMiddlewareFactory', ({ projectGroupMiddlewareFactory, authMiddlewareFactory }) =>
-				new ApiMiddlewareFactory(projectGroupMiddlewareFactory, authMiddlewareFactory))
-			.addService('stageResolveMiddlewareFactory', ({ httpErrorFactory }) =>
-				new StageResolveMiddlewareFactory(httpErrorFactory))
-			.addService('notModifiedMiddlewareFactory', () =>
-				new NotModifiedMiddlewareFactory())
-			.addService('projectMemberMiddlewareFactory', ({ debugMode, tenantContainer, httpErrorFactory }) =>
-				new ProjectMemberMiddlewareFactory(debugMode, tenantContainer.projectMemberManager, httpErrorFactory))
-			.addService('contentServerMiddlewareFactory', () =>
-				new ContentServerMiddlewareFactory())
-			.addService(
-				'koa',
-				({
-					 tenantGraphQlMiddlewareFactory,
-					 systemGraphQLMiddlewareFactory,
-					 apiMiddlewareFactory,
-					 projectResolverMiddlewareFactory,
-					 stageResolveMiddlewareFactory,
-					 notModifiedMiddlewareFactory,
-					 projectMemberMiddlewareFactory,
-					 contentServerMiddlewareFactory,
-					 promRegistry,
-					 debugMode,
-					 version,
-					 config,
-				 }) => {
-					const app = new Koa()
-					app.use(
-						compose([
-							koaCompress({
-								br: false,
-							}),
-							bodyParser({
-								jsonLimit: config.server.http.requestBodySize || '1mb',
-							}),
-							createPoweredByHeaderMiddleware(debugMode, version ?? 'unknown'),
-							createColllectHttpMetricsMiddleware(promRegistry),
-							createTimerMiddleware(),
-							route('/playground$', createPlaygroundMiddleware()),
-							createHomepageMiddleware(),
-							route(
-								'/content/:projectSlug/:stageSlug$',
-								compose([
-									apiMiddlewareFactory.create('content'),
-									projectResolverMiddlewareFactory.create(),
-									stageResolveMiddlewareFactory.create(),
-									notModifiedMiddlewareFactory.create(),
-									projectMemberMiddlewareFactory.create(),
-									contentServerMiddlewareFactory.create(),
-								]),
-							),
-							route(
-								'/tenant$',
-								compose([
-									apiMiddlewareFactory.create('tenant'),
-									tenantGraphQlMiddlewareFactory.create(),
-								]),
-							),
-							route(
-								'/system/:projectSlug$',
-								compose([
-									apiMiddlewareFactory.create('system'),
-									projectResolverMiddlewareFactory.create(),
-									projectMemberMiddlewareFactory.create(),
-									systemGraphQLMiddlewareFactory.create(),
-								]),
-							),
-						]),
-					)
+			.addService('httpErrorMiddlewareFactory', ({ debugMode }) =>
+				new ErrorMiddlewareFactory(debugMode))
+			.addService('projectGroupResolver', ({ projectGroupContainerResolver, serverConfig }) => {
+				const encryptionKey = serverConfig.projectGroup?.configEncryptionKey
+					? createSecretKey(Buffer.from(serverConfig.projectGroup?.configEncryptionKey, 'hex'))
+					: undefined
+				return new ProjectGroupResolver(
+					serverConfig.projectGroup?.domainMapping,
+					serverConfig.projectGroup?.configHeader,
+					serverConfig.projectGroup?.configEncryptionKey ? new CryptoWrapper(encryptionKey) : undefined,
+					projectGroupContainerResolver,
+				)
+			})
+			.addService('notModifiedChecker', () =>
+				new NotModifiedChecker())
+			.addService('contentGraphqlContextFactory', ({ providers }) =>
+				new ContentGraphQLContextFactory(providers))
+			.addService('contentQueryHandlerFactory', ({ debugMode }) =>
+				new ContentQueryHandlerFactory(debugMode, logSentryError))
+			.addService('contentApiMiddlewareFactory', ({ debugMode, projectGroupResolver, notModifiedChecker, contentGraphqlContextFactory, contentQueryHandlerFactory }) =>
+				new ContentApiMiddlewareFactory(debugMode, projectGroupResolver, notModifiedChecker, contentGraphqlContextFactory, contentQueryHandlerFactory))
+			.addService('tenantGraphQLContextFactory', () =>
+				new TenantGraphQLContextFactory())
+			.addService('tenantApiMiddlewareFactory', ({ debugMode, projectGroupResolver, tenantGraphQLContextFactory }) =>
+				new TenantApiMiddlewareFactory(debugMode, projectGroupResolver, tenantGraphQLContextFactory))
+			.addService('systemGraphQLContextFactory', () =>
+				new SystemGraphQLContextFactory())
+			.addService('systemApiMiddlewareFactory', ({ debugMode, projectGroupResolver, systemGraphQLContextFactory }) =>
+				new SystemApiMiddlewareFactory(debugMode, projectGroupResolver, systemGraphQLContextFactory))
+			.addService('koa', ({ contentApiMiddlewareFactory, tenantApiMiddlewareFactory, systemApiMiddlewareFactory, httpErrorMiddlewareFactory, promRegistry, debugMode, version, serverConfig }) => {
+				const app = new Koa()
+				app.use(
+					compose([
+						koaCompress({
+							br: false,
+						}),
+						bodyParser({
+							jsonLimit: serverConfig.http.requestBodySize || '1mb',
+						}),
+						createPoweredByHeaderMiddleware(debugMode, version ?? 'unknown'),
+						httpErrorMiddlewareFactory.create(),
+						createColllectHttpMetricsMiddleware(promRegistry),
+						createTimerMiddleware(),
+						route('/playground$', createPlaygroundMiddleware()),
+						createHomepageMiddleware(),
+						corsMiddleware(),
+						route(
+							'/content/:projectSlug/:stageSlug$',
+							compose([
+								createModuleInfoMiddleware('content'),
+								contentApiMiddlewareFactory.create(),
+							]),
+						),
+						route(
+							'/tenant$',
+							compose([
+								createModuleInfoMiddleware('tenant'),
+								tenantApiMiddlewareFactory.create(),
+							]),
+						),
+						route(
+							'/system/:projectSlug$',
+							compose([
+								createModuleInfoMiddleware('system'),
+								systemApiMiddlewareFactory.create(),
+							]),
+						),
+					]),
+				)
 
-					return app
-				},
-			)
+				return app
+			})
 			.addService('monitoringKoa', ({ promRegistry }) => {
 				const app = new Koa()
 				app.use(createShowMetricsMiddleware(promRegistry))
 
 				return app
 			})
-			.addService(
-				'initializer',
-				({ tenantContainer, systemContainer, projectContainerResolver }) =>
-					new Initializer(
-						tenantContainer.migrationsRunnerFactory,
-						tenantContainer.projectManager,
-						systemContainer.projectInitializer,
-						projectContainerResolver,
-						tenantContainer.projectGroupProvider,
-					),
-			)
-			.setupService('projectSchemaResolver', (it, { projectContainerResolver, schemaVersionBuilder }) => {
-				it.setResolver(new ProjectSchemaResolver(projectContainerResolver, schemaVersionBuilder))
-			})
-			.setupService('projectInitializer', (it, { projectContainerResolver }) => {
-				it.setInitializer(new ProjectInitializer(projectContainerResolver))
-			})
-			.build()
+			.addService('initializer', ({ projectGroupContainerResolver }) =>
+				new Initializer(projectGroupContainerResolver))
+
+	}
 
-		return masterContainer.pick('initializer', 'koa', 'monitoringKoa', 'projectContainerResolver', 'projectInitializer', 'providers')
+	create(args: MasterContainerArgs): MasterContainer {
+		const container = this.createBuilder(args).build()
+		return container.pick('initializer', 'koa', 'monitoringKoa', 'providers')
 	}
 }

package/src/bootstrap/Initializer.ts

@@ -1,17 +1,9 @@
-import { MigrationsRunnerFactory, ProjectGroupProvider, ProjectManager } from '@contember/engine-tenant-api'
-import { ProjectInitializer } from '@contember/engine-system-api'
 import { Logger } from '@contember/engine-common'
-import { ProjectContainerResolver } from '../project'
-import { ProjectConfig } from '@contember/engine-http'
-import { Migration } from '@contember/schema-migrations'
+import { ProjectGroupContainerResolver } from '../projectGroup/ProjectGroupContainerResolver'
 
 export class Initializer {
 	constructor(
-		private readonly tenantDbMigrationsRunnerFactory: MigrationsRunnerFactory,
-		private readonly projectManager: ProjectManager,
-		private readonly projectInitializer: ProjectInitializer,
-		private readonly projectContainerResolver: ProjectContainerResolver,
-		private readonly projectGroupProvider: ProjectGroupProvider,
+		private readonly projectGroupContainerResolver: ProjectGroupContainerResolver,
 	) {}
 
 	public async initialize(): Promise<string[]> {
@@ -19,39 +11,22 @@ export class Initializer {
 		const logger = new Logger(console.log)
 		logger.group('\nInitializing tenant database')
 		// todo
-		await this.tenantDbMigrationsRunnerFactory.create('tenant').run(logger.write.bind(logger))
+		const groupContainer = await this.projectGroupContainerResolver.getProjectGroupContainer(undefined)
+
+		await groupContainer.tenantContainer.migrationsRunner.run(logger.write.bind(logger))
 		logger.groupEnd()
 
+		const systemContainer = groupContainer.systemContainer
 		const projects: string[] = []
-		const group = await this.projectGroupProvider.getGroup(undefined)
-		for (const container of await this.projectContainerResolver.getAllProjectContainers(group)) {
-			const project = container.project
+		for (const projectContainer of await groupContainer.projectContainerResolver.getAllProjectContainers()) {
+			const project = projectContainer.project
 			projects.push(project.slug)
 			logger.group(`\nUpdating project ${project.slug}`)
-			await this.projectInitializer.initialize(container.systemDatabaseContextFactory, project, logger)
+			await systemContainer.projectInitializer.initialize(projectContainer.systemDatabaseContextFactory, project, logger)
 			logger.groupEnd()
 		}
 		// eslint-disable-next-line no-console
 		console.log('')
 		return projects
 	}
-
-	public async createProject(project: ProjectConfig, migrations: Migration[]): Promise<void> {
-		const { slug, name, ...config } = project
-		const group = await this.projectGroupProvider.getGroup(undefined)
-		const result = await this.projectManager.createProject(group, { slug, name, config, secrets: {} }, undefined)
-		if (!result) {
-			throw new Error('Project already exists')
-		}
-		const container = await this.projectContainerResolver.getProjectContainer(group, project.slug)
-		if (!container) {
-			throw new Error('Should not happen')
-		}
-		await this.projectInitializer.initialize(
-			container.systemDatabaseContextFactory,
-			project,
-			new Logger(() => null),
-			migrations,
-		)
-	}
 }