@contember/engine-server 1.1.0-rc.0 → 1.2.0-alpha.1

package/src/projectGroup/ProjectGroupContainer.ts

@@ -6,6 +6,8 @@ import {
 	Authenticator,
 	CryptoWrapper,
 	ProjectGroupContainer,
+	ProjectMembershipFetcher,
+	ProjectMembershipResolver,
 	Providers,
 	SystemGraphQLHandlerFactory,
 	TenantGraphQLHandlerFactory,
@@ -30,6 +32,7 @@ interface ProjectGroupContainerFactoryArgs
 
 export class ProjectGroupContainerFactory {
 	constructor(
+		private readonly debug: boolean,
 		private readonly providers: Providers,
 		private readonly systemContainerFactory: SystemContainerFactory,
 		private readonly tenantContainerFactory: TenantContainerFactory,
@@ -45,13 +48,15 @@ export class ProjectGroupContainerFactory {
 				slug)
 			.addService('providers', () =>
 				this.providers)
-			.addService('tenantConnection', (): Connection.ConnectionType =>
-				new Connection(config.db, {}))
+			.addService('tenantDbCredentials', () =>
+				config.db)
+			.addService('tenantConnection', ({ tenantDbCredentials }): Connection.ConnectionType =>
+				Connection.create(tenantDbCredentials, {}))
 			.addService('projectSchemaResolver', () =>
 				new ProjectSchemaResolverProxy())
 			.addService('projectInitializer', () =>
 				new ProjectInitializerProxy())
-			.addService('tenantContainer', ({ tenantConnection, projectSchemaResolver, projectInitializer }) => {
+			.addService('tenantContainer', ({ tenantConnection, tenantDbCredentials, projectSchemaResolver, projectInitializer }) => {
 				const encryptionKey = config.secrets.encryptionKey
 					? createSecretKey(Buffer.from(config.secrets.encryptionKey, 'hex'))
 					: undefined
@@ -59,6 +64,7 @@ export class ProjectGroupContainerFactory {
 				const cryptoWrapper = new CryptoWrapper(encryptionKey)
 				return this.tenantContainerFactory.create({
 					connection: tenantConnection,
+					dbCredentials: tenantDbCredentials,
 					mailOptions: config.mailer,
 					tenantCredentials: config.credentials,
 					projectInitializer,
@@ -103,6 +109,8 @@ export class ProjectGroupContainerFactory {
 				this.systemGraphQLHandlerFactory.create(systemContainer.systemResolversFactory))
 			.addService('authenticator', ({ tenantDatabase, tenantContainer }) =>
 				new Authenticator(tenantDatabase, tenantContainer.apiKeyManager))
+			.addService('projectMembershipResolver', ({ tenantContainer }) =>
+				new ProjectMembershipResolver(this.debug, new ProjectMembershipFetcher(tenantContainer.projectMemberManager, tenantContainer.databaseContext)))
 			.build()
 			.pick(
 				'projectContainerResolver',
@@ -113,6 +121,7 @@ export class ProjectGroupContainerFactory {
 				'tenantContainer',
 				'tenantDatabase',
 				'authenticator',
+				'projectMembershipResolver',
 				'tenantGraphQLHandler',
 				'slug',
 			)

package/src/projectGroup/ProjectGroupResolver.ts

@@ -0,0 +1,12 @@
+import { ProjectGroupContainer, ProjectGroupResolver as ProjectGroupResolverInterface } from '@contember/engine-http'
+
+export class ProjectGroupResolver implements ProjectGroupResolverInterface {
+	constructor(
+		private readonly projectGroupContainer: ProjectGroupContainer,
+	) {
+	}
+
+	resolveContainer(): Promise<ProjectGroupContainer> {
+		return Promise.resolve(this.projectGroupContainer)
+	}
+}

package/src/start.ts

@@ -1,85 +1,28 @@
 #!/usr/bin/env node
 
-import { createContainer, readConfig } from './index'
-import { Server } from 'net'
+import { createContainer, listenOnProcessTermination, serverConfigSchema, TerminationJob } from './index'
 import loadPlugins from './loadPlugins'
-import { ConfigProcessor } from '@contember/engine-plugins'
-import { join } from 'path'
-import os from 'os'
-import cluster from 'cluster'
-import { getClusterProcessType, initSentry, notifyWorkerStarted, timeout, waitForWorker } from './utils'
-import { ConfigSource } from './config/config'
+import { initSentry } from './utils'
 
-const createServerTerminator = (): Server[] => {
-	const signals = [
-		['SIGHUP', 1],
-		['SIGINT', 2],
-		['SIGTERM', 15],
-	] as const
 
-	let servers: Server[] = []
-	for (const [signal, code] of signals) {
-		process.on(signal, async () => {
-			// eslint-disable-next-line no-console
-			console.log(`process received a ${signal} signal`)
-			for (const server of servers) {
-				await new Promise(resolve => server.close(() => resolve(null)))
-			}
-			process.exit(128 + code)
-		})
-	}
-	return servers
-}
+import { getServerVersion, isDebugMode, printStartInfo, resolveServerConfig } from './utils/serverStartup'
 
-;(async () => {
+(async () => {
 	if (process.env.NODE_HEAPDUMP === 'true') {
 		// eslint-disable-next-line no-console
 		console.log('Initializing heapdump')
 		await import('heapdump')
 	}
-	const isDebug = process.env.NODE_ENV === 'development'
-	const packageJsonFile = process.env.CONTEMBER_PACKAGE_JSON || join(__dirname, '../../package.json')
-	// eslint-disable-next-line @typescript-eslint/no-var-requires
-	const version = require(packageJsonFile).version
-
-	if (cluster.isMaster) {
-		// eslint-disable-next-line no-console
-		console.log(`Starting Contember ${version}`)
-		// eslint-disable-next-line no-console
-		console.log(`NODE_ENV is set to ${process.env.NODE_ENV}`)
-		if (isDebug) {
-			// eslint-disable-next-line no-console
-			console.log('Starting Contember in debug mode')
-			// eslint-disable-next-line no-console
-			console.log('NEVER USE debug mode in production environment')
-		}
-	}
+	const terminationJobs: TerminationJob[] = []
+	listenOnProcessTermination(terminationJobs)
 
+	const isDebug = isDebugMode()
+	const version = getServerVersion()
+	printStartInfo({ version, isDebug })
 	const plugins = await loadPlugins()
-	const configProcessors = plugins
-		.map(it => (it.getConfigProcessor ? it.getConfigProcessor() : null))
-		.filter((it): it is ConfigProcessor => it !== null)
-
-	const configSources: ConfigSource[] = []
-	for (const configType of ['file', 'yaml', 'json'] as const) {
-		const envValue = process.env['CONTEMBER_CONFIG_' + configType.toUpperCase()]
-		if (envValue) {
-			configSources.push({ type: configType, data: envValue })
-		}
-	}
-
-	const { serverConfig, projectConfigResolver, tenantConfigResolver } = await readConfig(configSources, configProcessors)
-
-	if (process.argv[2] === 'validate') {
-		process.exit(0)
-	}
-	'sentry' in serverConfig.logging && initSentry(serverConfig.logging.sentry?.dsn)
-	const workerConfig = serverConfig.workerCount || 1
+	const { serverConfig, projectConfigResolver, tenantConfigResolver } = await resolveServerConfig({ plugins, serverConfigSchema })
 
-	const workerCount = workerConfig === 'auto' ? os.cpus().length : Number(workerConfig)
-	const isClusterMode = workerCount > 1
-
-	const processType = getClusterProcessType(isClusterMode)
+	initSentry(serverConfig.logging.sentry?.dsn)
 
 	const container = createContainer({
 		debugMode: isDebug,
@@ -87,70 +30,18 @@ const createServerTerminator = (): Server[] => {
 		projectConfigResolver,
 		tenantConfigResolver,
 		plugins,
-		processType,
 		version,
 	})
 
-	let initializedProjects: string[] = []
-	if (cluster.isMaster) {
-		const monitoringPort = serverConfig.monitoringPort
-		const terminator = createServerTerminator()
-		terminator.push(
-			container.monitoringKoa.listen(monitoringPort, () => {
-				// eslint-disable-next-line no-console
-				console.log(`Monitoring running on http://localhost:${monitoringPort}`)
-			}),
-		)
-		if (!serverConfig.projectGroup) {
-			initializedProjects = await container.initializer.initialize()
-		}
-	}
+	const initializedProjects: string[] = await container.initializer.initialize()
 
-	const port = serverConfig.port
-	const printStarted = () => {
-		if (serverConfig.projectGroup) {
-			// eslint-disable-next-line no-console
-			console.log('Contember Cloud running')
-		} else {
-			// eslint-disable-next-line no-console
-			console.log(`Contember API running on http://localhost:${port}`)
-			// eslint-disable-next-line no-console
-			console.log(initializedProjects.length ? `Initialized projects: ${initializedProjects.join(', ')}` : 'No project initialized')
-		}
-	}
-
-	if (isClusterMode && cluster.isMaster) {
+	const httpServer = container.koa.listen(serverConfig.port, () => {
 		// eslint-disable-next-line no-console
-		console.log(`Master ${process.pid} is running`)
-		for (let i = 0; i < workerCount; i++) {
-			cluster.fork()
-			await waitForWorker(15000)
-		}
-		printStarted()
-
-		cluster.on('exit', async (worker, code, signal) => {
-			// eslint-disable-next-line no-console
-			console.log(`Worker ${worker.process.pid} died with signal ${signal}, restarting`)
-			await timeout(2000)
-			cluster.fork()
-		})
-	} else {
-		if (isClusterMode) {
-			// eslint-disable-next-line no-console
-			console.log(`Starting worker ${process.pid}`)
-		}
-		const serverTerminator = createServerTerminator()
-
-		serverTerminator.push(
-			container.koa.listen(port, () => {
-				if (!isClusterMode) {
-					printStarted()
-				} else {
-					notifyWorkerStarted()
-				}
-			}),
-		)
-	}
+		console.log(`Contember API running on http://localhost:${(serverConfig.port)}`)
+		// eslint-disable-next-line no-console
+		console.log(initializedProjects.length ? `Initialized projects: ${initializedProjects.join(', ')}` : 'No project initialized')
+	})
+	terminationJobs.push(() => new Promise<any>(resolve => httpServer.close(resolve)))
 })().catch(e => {
 	// eslint-disable-next-line no-console
 	console.log(e)

package/src/utils/index.ts

@@ -1,6 +1,2 @@
-export * from './cluster'
-export * from './dbMetrics'
 export * from './sentry'
 export * from './strings'
-export * from './timeout'
-export * from './tuple'

package/src/utils/serverStartup.ts

@@ -0,0 +1,42 @@
+import { join } from 'path'
+import { ConfigProcessor, Plugin } from '@contember/engine-plugins'
+import { ConfigSource, readConfig, ServerConfig } from '../config/config'
+import { Type } from '@contember/typesafe'
+
+export const getServerVersion = (): string => {
+	const packageJsonFile = process.env.CONTEMBER_PACKAGE_JSON || join(__dirname, '../../../package.json')
+	// eslint-disable-next-line @typescript-eslint/no-var-requires
+	const version = require(packageJsonFile).version
+	return version
+}
+
+export const isDebugMode = (): boolean => process.env.NODE_ENV === 'development'
+
+export const printStartInfo = ({ version, isDebug }: { version: string; isDebug: boolean }) => {
+	// eslint-disable-next-line no-console
+	console.log(`Starting Contember ${version}`)
+	// eslint-disable-next-line no-console
+	console.log(`NODE_ENV is set to ${process.env.NODE_ENV}`)
+	if (isDebug) {
+		// eslint-disable-next-line no-console
+		console.log('Starting Contember in debug mode')
+		// eslint-disable-next-line no-console
+		console.log('NEVER USE debug mode in production environment')
+	}
+}
+
+export const resolveServerConfig = async <T extends ServerConfig>({ plugins, serverConfigSchema }: { plugins: Plugin[]; serverConfigSchema: Type<T> }) => {
+	const configProcessors = plugins
+		.map(it => (it.getConfigProcessor ? it.getConfigProcessor() : null))
+		.filter((it): it is ConfigProcessor => it !== null)
+
+	const configSources: ConfigSource[] = []
+	for (const configType of ['file', 'yaml', 'json'] as const) {
+		const envValue = process.env['CONTEMBER_CONFIG_' + configType.toUpperCase()]
+		if (envValue) {
+			configSources.push({ type: configType, data: envValue })
+		}
+	}
+
+	return await readConfig(configSources, configProcessors, serverConfigSchema)
+}

package/src/utils/serverTermination.ts

@@ -0,0 +1,20 @@
+import cluster from 'cluster'
+
+const signals = {
+	SIGHUP: 1,
+	SIGINT: 2,
+	SIGTERM: 15,
+}
+export type TerminationJob = (args: { signal: keyof typeof signals; code: number }) => Promise<void>
+export const listenOnProcessTermination = (jobs: TerminationJob[]) => {
+	for (const [signal, code] of Object.entries(signals)) {
+		process.on(signal, async () => {
+			// eslint-disable-next-line no-console
+			console.log(`Process ${process.pid} received a ${signal} signal, executing ${jobs.length} termination jobs`)
+			await Promise.allSettled(jobs.map(it => it({ signal: signal as keyof typeof signals, code })))
+			// eslint-disable-next-line no-console
+			console.log(cluster.isMaster ? `All terminated, exiting` : 'All terminated, exiting a worker')
+			process.exit(128 + code)
+		})
+	}
+}

package/tests/e2e/http.test.ts

@@ -1,113 +1,10 @@
 import supertest from 'supertest'
-import * as nodeAssert from 'assert'
-import { assert, beforeAll, test } from 'vitest'
-import { MigrationFilesManager, MigrationsResolver } from '@contember/schema-migrations'
-import { getExampleProjectDirectory } from '@contember/engine-api-tester'
+import { assert, test } from 'vitest'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+import { apiUrl, createTester, gql } from './tester'
+import { addProjectMember, signIn, signUp } from './requests'
 
 
-const rootToken = String(process.env.CONTEMBER_ROOT_TOKEN)
-const loginToken = String(process.env.CONTEMBER_LOGIN_TOKEN)
-const apiUrl = String(process.env.CONTEMBER_API_URL)
-let projectSlug = ''
-
-// Used to allow prettier formatting of GraphQL queries
-const gql = (strings: TemplateStringsArray) => {
-	nodeAssert.strictEqual(strings.length, 1)
-	return strings[0]
-}
-
-
-const executeGraphql = (
-	query: string,
-	options: { authorizationToken?: string; path?: string; variables?: Record<string, any> } = {},
-) => {
-	return supertest(apiUrl)
-		.post(options.path || `/content/${projectSlug}/live`)
-		.set('Authorization', 'Bearer ' + (options.authorizationToken || rootToken))
-		.send({
-			query,
-			variables: options.variables || {},
-		})
-}
-
-const signIn = async (email: string, password: string): Promise<string> => {
-	const response2 = await executeGraphql(
-		gql`
-			mutation ($email: String!, $password: String!) {
-				signIn(email: $email, password: $password) {
-					ok
-					result {
-						token
-					}
-				}
-			}
-		`,
-		{
-			variables: { email, password },
-			authorizationToken: loginToken,
-			path: '/tenant',
-		},
-	)
-
-	return response2.body.data.signIn.result.token
-}
-
-beforeAll(async () => {
-	projectSlug = 'test' + Date.now()
-	const result = await executeGraphql(`
-		mutation($projectSlug: String!, $config: Json!) {
-			createProject(projectSlug: $projectSlug, config: $config) {
-				ok
-				error { code }
-			}
-		}
-	`,
-	{
-		path: '/tenant',
-		variables: {
-			projectSlug: projectSlug,
-			config: {},
-		},
-	})
-		.expect(response => {
-			assert.isOk(response.body)
-			assert.isOk(response.body.data)
-			assert.isOk(response.body.data.createProject)
-			if (!response.body.data.createProject.ok) {
-				assert.equal(response.body.data.createProject.error.code, 'ALREADY_EXISTS')
-			}
-		})
-		.expect(200)
-	if (!result.body.data.createProject.ok) {
-		return
-	}
-	const migrationFilesManager = new MigrationsResolver(MigrationFilesManager.createForProject(getExampleProjectDirectory(), 'sample'))
-	const migrations = await migrationFilesManager.getMigrations()
-	assert.isAtLeast(migrations.length, 2)
-	await executeGraphql(`
-		mutation($migrations: [Migration!]!) {
-			migrate(migrations: $migrations) {
-				ok
-				error { code }
-			}
-		}
-	`,
-	{
-		path: '/system/' + projectSlug,
-		variables: {
-			migrations,
-		},
-	})
-		.expect(response => {
-			assert.deepStrictEqual(response.body.data, {
-				migrate: {
-					error: null,
-					ok: true,
-				},
-			})
-		})
-})
-
 test('show homepage', async () => {
 	await supertest(apiUrl)
 		.get('/')
@@ -115,8 +12,16 @@ test('show homepage', async () => {
 		.expect('App is running')
 })
 
+namespace TagModel {
+	export class Tag {
+		label = def.stringColumn()
+	}
+}
+
 test('Content API: create & read tag', async () => {
-	await executeGraphql(
+	const tester = await createTester(createSchema(TagModel))
+
+	await tester(
 		gql`
 			mutation {
 				createTag(data: { label: "graphql" }) {
@@ -134,7 +39,7 @@ test('Content API: create & read tag', async () => {
 		})
 		.expect(200)
 
-	await executeGraphql(
+	await tester(
 		gql`
 			query {
 				listTag(filter: { label: { eq: "graphql" } }) {
@@ -156,7 +61,10 @@ test('Content API: create & read tag', async () => {
 })
 
 test('Content API: X-Contember-Ref header', async () => {
-	await executeGraphql(
+
+	const tester = await createTester(createSchema(TagModel))
+
+	await tester(
 		gql`
 			mutation {
 				createTag(data: { label: "typescript" }) {
@@ -166,7 +74,7 @@ test('Content API: X-Contember-Ref header', async () => {
 		`,
 	).expect(200)
 
-	const response = await executeGraphql(
+	const response = await tester(
 		gql`
 			query {
 				listTag(filter: { label: { eq: "typescript" } }) {
@@ -187,7 +95,7 @@ test('Content API: X-Contember-Ref header', async () => {
 		})
 		.expect(200)
 	const eventKey = response.get('X-Contember-Ref')
-	await executeGraphql(
+	await tester(
 		gql`
 			query {
 				listTag {
@@ -200,7 +108,7 @@ test('Content API: X-Contember-Ref header', async () => {
 		.expect(304)
 
 	// ignored for mutation
-	await executeGraphql(
+	await tester(
 		gql`
 			mutation {
 				createTag(data: { label: "typescript" }) {
@@ -214,7 +122,9 @@ test('Content API: X-Contember-Ref header', async () => {
 })
 
 test('Content API: invalid schema error', async () => {
-	await executeGraphql(
+	const tester = await createTester(createSchema(TagModel))
+
+	await tester(
 		gql`
 			mutation {
 				createFoo(data: { label: "graphql" }) {
@@ -227,38 +137,35 @@ test('Content API: invalid schema error', async () => {
 		.expect(response => {
 			assert.deepStrictEqual(
 				response.body.errors[0].message,
-				'Cannot query field "createFoo" on type "Mutation". Did you mean "createPost" or "createTag"?',
+				'Cannot query field "createFoo" on type "Mutation". Did you mean "createTag"?',
 			)
 		})
 })
 
 test('Tenant API: sign up, add to a project and check project access', async () => {
+	const tester = await createTester(createSchema(TagModel))
+
 	const email = `john+${Date.now()}@doe.com`
-	const signUpResponse = await executeGraphql(
+	const identityId = await signUp(email)
+	const authKey = await signIn(email)
+
+	await tester(
 		gql`
-			mutation($email: String!) {
-				signUp(email: $email, password: "123456") {
-					ok
-					result {
-						person {
-							identity {
-								id
-							}
-						}
-					}
+			query {
+				listTag {
+					id
 				}
 			}
 		`,
-		{
-			path: '/tenant',
-			variables: { email },
-		},
-	).expect(200)
+		{ authorizationToken: authKey },
+	)
+		.expect(404)
+		.expect({ errors: [{ message: `Project ${tester.projectSlug} NOT found`, code: 404 }] })
+
 
-	const identityId = signUpResponse.body.data.signUp.result.person.identity.id
+	await addProjectMember(identityId, tester.projectSlug)
 
-	const authKey = await signIn(email, '123456')
-	await executeGraphql(
+	await tester(
 		gql`
 			query {
 				listTag {
@@ -268,36 +175,63 @@ test('Tenant API: sign up, add to a project and check project access', async ()
 		`,
 		{ authorizationToken: authKey },
 	)
-		.expect(404)
-		.expect({ errors: [{ message: `Project ${projectSlug} NOT found`, code: 404 }] })
+		.expect(response => {
+			assert.deepStrictEqual(response.body.data, { listTag: [] })
+		})
+		.expect(200)
+})
+
+
+test('Content API: assume membership', async () => {
+	const tester = await createTester(createSchema(TagModel, schema => {
+		return {
+			...schema,
+			acl: {
+				roles: {
+					test: {
+						entities: {},
+						variables: {},
+						content: {
+							assumeMembership: {
+								admin: {},
+							},
+						},
+					},
+				},
+			},
+		}
+	}))
+
+	const email = `john+${Date.now()}@doe.com`
+	const identityId = await signUp(email)
+	const authKey = await signIn(email)
+	await addProjectMember(identityId, tester.projectSlug, 'test')
 
-	await executeGraphql(
+	await tester(
 		gql`
-			mutation ($identity: String!, $projectSlug: String!) {
-				addProjectMember(identityId: $identity, projectSlug: $projectSlug, memberships: [{ role: "admin", variables: [] }]) {
-					ok
+			query {
+				listTag {
+					id
 				}
 			}
 		`,
-		{ path: '/tenant', variables: { identity: identityId, projectSlug } },
+		{ authorizationToken: authKey },
 	)
-		.expect(200)
-		.expect(response => {
-			assert.deepStrictEqual(response.body.data, { addProjectMember: { ok: true } })
-		})
+		.expect(400)
+
 
-	await executeGraphql(
+
+	await tester(
 		gql`
 			query {
-				listAuthor {
+				listTag {
 					id
 				}
 			}
 		`,
 		{ authorizationToken: authKey },
 	)
-		.expect(response => {
-			assert.deepStrictEqual(response.body.data, { listAuthor: [] })
-		})
+		.set('X-Contember-assume-membership', JSON.stringify({ memberships: [{ role: 'admin', variables: [] }] }))
+		.expect({ data: { listTag: [] } })
 		.expect(200)
 })