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

package/src/project/ProjectSchemaResolver.ts

@@ -1,33 +0,0 @@
-import { ProjectSchemaResolver as ProjectSchemaResolverInterface } from '@contember/engine-tenant-api'
-import { ProjectContainerResolver } from '@contember/engine-http'
-import { Schema } from '@contember/schema'
-
-export class ProjectSchemaResolver implements ProjectSchemaResolverInterface {
-	constructor(
-		private readonly projectContainerResolver: ProjectContainerResolver,
-	) {}
-
-	async getSchema(slug: string) {
-		const container = await this.projectContainerResolver.getProjectContainer(slug)
-		if (!container) {
-			return undefined
-		}
-		const db = container.systemDatabaseContextFactory.create()
-		return container.contentSchemaResolver.getSchema(db)
-	}
-}
-
-export class ProjectSchemaResolverProxy implements ProjectSchemaResolverInterface {
-	private resolver: ProjectSchemaResolver | undefined
-
-	setResolver(resolver: ProjectSchemaResolver): void {
-		this.resolver = resolver
-	}
-
-	getSchema(projectSlug: string): Promise<Schema | undefined> {
-		if (!this.resolver) {
-			throw new Error('Resolved is not set')
-		}
-		return this.resolver.getSchema(projectSlug)
-	}
-}

package/src/project/index.ts

@@ -1,4 +0,0 @@
-export * from './ProjectInitializer'
-export * from './ProjectSchemaResolver'
-export * from './ProjectContainer'
-export * from './ProjectContainerResolver'

package/src/projectGroup/ProjectGroupContainer.ts

@@ -1,134 +0,0 @@
-import { Builder } from '@contember/dic'
-import { Connection } from '@contember/database'
-import { TenantContainerFactory } from '@contember/engine-tenant-api'
-import { TenantConfig } from '../config/config'
-import {
-	Authenticator,
-	CryptoWrapper,
-	ProjectGroupContainer,
-	ProjectMembershipFetcher,
-	ProjectMembershipResolver,
-	Providers,
-	SystemGraphQLHandlerFactory,
-	TenantGraphQLHandlerFactory,
-} from '@contember/engine-http'
-import {
-	ProjectContainerFactoryFactory,
-	ProjectContainerResolver,
-	ProjectInitializer,
-	ProjectInitializerProxy,
-	ProjectSchemaResolver,
-	ProjectSchemaResolverProxy,
-} from '../project'
-import { SystemContainerFactory } from '@contember/engine-system-api'
-import { ProjectConfigResolver } from '../config/projectConfigResolver'
-import { createSecretKey } from 'node:crypto'
-import { Logger } from '@contember/logger'
-
-interface ProjectGroupContainerFactoryArgs
-{
-	config: TenantConfig
-	slug: string | undefined
-}
-
-export class ProjectGroupContainerFactory {
-	constructor(
-		private readonly debug: boolean,
-		private readonly providers: Providers,
-		private readonly systemContainerFactory: SystemContainerFactory,
-		private readonly tenantContainerFactory: TenantContainerFactory,
-		private readonly projectContainerFactoryFactory: ProjectContainerFactoryFactory,
-		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, logger }): Connection.ConnectionType =>
-				Connection.create(tenantDbCredentials, err => logger.error(err)))
-			.addService('projectSchemaResolver', () =>
-				new ProjectSchemaResolverProxy())
-			.addService('projectInitializer', () =>
-				new ProjectInitializerProxy())
-			.addService('tenantContainer', ({ tenantConnection, tenantDbCredentials, projectSchemaResolver, projectInitializer }) => {
-				const encryptionKey = config.secrets.encryptionKey
-					? createSecretKey(Buffer.from(config.secrets.encryptionKey, 'hex'))
-					: undefined
-
-				const cryptoWrapper = new CryptoWrapper(encryptionKey)
-				return this.tenantContainerFactory.create({
-					connection: tenantConnection,
-					dbCredentials: tenantDbCredentials,
-					mailOptions: config.mailer,
-					tenantCredentials: config.credentials,
-					projectInitializer,
-					projectSchemaResolver,
-					cryptoProviders: {
-						decrypt: cryptoWrapper.decrypt.bind(cryptoWrapper),
-						encrypt: cryptoWrapper.encrypt.bind(cryptoWrapper),
-					},
-				})
-			})
-			.addService('tenantDatabase', ({ tenantContainer }) =>
-				tenantContainer.databaseContext)
-			.addService('identityFetcher', ({ tenantContainer: { identityFetcher } }) =>
-				identityFetcher)
-			.addService('systemContainer', ({ identityFetcher }) =>
-				this.systemContainerFactory.create({ identityFetcher }))
-			.addService('schemaVersionBuilder', ({ systemContainer }) =>
-				systemContainer.schemaVersionBuilder)
-			.addService('projectContainerFactory', ({  schemaVersionBuilder, logger }) =>
-				this.projectContainerFactoryFactory.create(schemaVersionBuilder, logger))
-			.addService('tenantProjectManager', ({ tenantContainer }) =>
-				tenantContainer.projectManager)
-			.addService('projectContainerResolver', ({ projectContainerFactory, tenantProjectManager, systemContainer, tenantContainer }) =>
-				new ProjectContainerResolver(
-					projectContainerFactory,
-					this.projectConfigResolver,
-					tenantProjectManager,
-					systemContainer.projectInitializer,
-					tenantContainer.databaseContext,
-					config,
-				))
-
-			.setupService('projectSchemaResolver', (it, { projectContainerResolver }) => {
-				it.setResolver(new ProjectSchemaResolver(projectContainerResolver))
-			})
-			.setupService('projectInitializer', (it, { projectContainerResolver }) => {
-				it.setInitializer(new ProjectInitializer(projectContainerResolver))
-			})
-			.addService('tenantGraphQLHandler', ({ tenantContainer }) =>
-				this.tenantGraphQLHandlerFactory.create(tenantContainer.resolvers))
-			.addService('systemGraphQLHandler', ({ systemContainer }) =>
-				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',
-				'projectSchemaResolver',
-				'projectInitializer',
-				'systemContainer',
-				'systemGraphQLHandler',
-				'tenantContainer',
-				'tenantDatabase',
-				'authenticator',
-				'projectMembershipResolver',
-				'tenantGraphQLHandler',
-				'slug',
-				'logger',
-			)
-	}
-}

package/src/projectGroup/ProjectGroupResolver.ts

@@ -1,12 +0,0 @@
-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/utils/index.ts

@@ -1,2 +0,0 @@
-export * from './sentry'
-export * from './strings'

package/src/utils/sentry.ts

@@ -1,56 +0,0 @@
-import * as Sentry from '@sentry/node'
-import { LoggerRequestSymbol } from '@contember/engine-http'
-import { LogEntry, LoggerHandler, LogLevel, LogLevels } from '@contember/logger'
-
-export class SentryLoggerHandler implements LoggerHandler {
-	constructor(
-		private readonly logLevel: LogLevel,
-	) {
-	}
-
-	getMinLevel(): number {
-		return this.logLevel.value
-	}
-
-	handle(entry: LogEntry) {
-		if (!entry.error || entry.level.value < this.logLevel.value) {
-			return
-		}
-		Sentry.captureException(entry.error, scope => {
-			scope.setTag('project', entry.loggerAttributes.project ?? entry.ownAttributes.project)
-			scope.setTag('module', entry.loggerAttributes.module ?? entry.ownAttributes.module)
-			scope.setLevel('error')
-			scope.setUser({
-				id: entry.loggerAttributes.user ?? entry.ownAttributes.user,
-			})
-			scope.setExtra('requestId', entry.loggerAttributes.requestId)
-
-			scope.addEventProcessor(event => {
-				return {
-					...event,
-					request: {
-						url: entry.loggerAttributes.url ?? entry.ownAttributes.url,
-						data: entry.loggerAttributes[LoggerRequestSymbol]?.body,
-					},
-				}
-			})
-			return scope
-		})
-	}
-
-	close(): void {
-	}
-}
-
-export const createSentryLoggerHandler = (dsn?: string): null | LoggerHandler => {
-	if (!dsn) {
-		return null
-	}
-	Sentry.init({
-		dsn: dsn,
-		integrations: integrations => {
-			return integrations.filter(integration => integration.name !== 'Console' && integration.name !== 'Http')
-		},
-	})
-	return new SentryLoggerHandler(LogLevels.warn)
-}

package/src/utils/serverStartup.ts

@@ -1,78 +0,0 @@
-import { join } from 'node:path'
-import { ConfigProcessor, Plugin } from '@contember/engine-plugins'
-import { ConfigSource, readConfig, ServerConfig } from '../config/config'
-import { Type } from '@contember/typesafe'
-import { createLogger, JsonStreamLoggerHandler, Logger, LogLevels, PrettyPrintLoggerHandler } from '@contember/logger'
-
-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 }, logger: Logger) => {
-	logger.info(`Starting Contember ${version}`)
-	logger.info(`NODE_ENV is set to ${process.env.NODE_ENV}`)
-	if (isDebug) {
-		logger.warn('Starting Contember in debug mode')
-		logger.warn('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)
-}
-
-export const createDefaultLogger = (): Logger => {
-	const isDebug = isDebugMode()
-	const loggerType = process.env.CONTEMBER_LOGGER_FORMAT ?? (isDebug ? 'pretty' : 'json')
-	const stream = process.stderr
-	const handler = loggerType === 'pretty'
-		? new PrettyPrintLoggerHandler(stream, {
-			formatters: {
-				pid: () => undefined,
-				loggerId: () => undefined,
-				uri: ({ attributes, chalk }) => {
-					const color = attributes.status === undefined
-						? chalk.cyan
-						: attributes.status < 300
-							? chalk.green
-							: chalk.yellowBright
-					const timeInfo = attributes.totalTimeMs !== undefined ? ` ${attributes.totalTimeMs}ms` : ''
-					const statusInfo = attributes.status !== undefined ? ` [${attributes.status}]` : ''
-					return { line: color(`${attributes.method}${statusInfo} ${attributes.uri}${timeInfo} ${chalk.white.dim('#' + attributes.requestId)}`) }
-				},
-				method: () => undefined,
-				requestId: () => undefined,
-				timeLabel: () => undefined,
-				status: () => undefined,
-				totalTimeMs: () => undefined,
-				events: ({ formattedValue }) => formattedValue === '[]' ? undefined : formattedValue,
-			},
-		})
-		: new JsonStreamLoggerHandler(stream)
-	const logLevel = (process.env.CONTEMBER_LOGGER_LEVEL as keyof typeof LogLevels) ?? 'info'
-	return createLogger(handler, {
-		pid: process.pid,
-		loggerId: Math.random().toString().substring(2),
-	}, {
-		fingerCrossedOptions: {
-			logAlwaysLevel: LogLevels[logLevel],
-		},
-	})
-}

package/src/utils/serverTermination.ts

@@ -1,19 +0,0 @@
-import cluster from 'node:cluster'
-import { Logger } from '@contember/logger'
-
-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[], logger: Logger) => {
-	for (const [signal, code] of Object.entries(signals)) {
-		process.on(signal, async () => {
-			logger.info(`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 })))
-			logger.info(cluster.isMaster ? `All terminated, exiting` : 'All terminated, exiting a worker')
-			process.exit(128 + code)
-		})
-	}
-}

package/src/utils/strings.ts

@@ -1 +0,0 @@
-export const upperCaseFirst = (string: string) => `${string.charAt(0).toUpperCase()}${string.substring(1)}`

package/tests/cases/configResolver.test.ts

@@ -1,67 +0,0 @@
-import { assert, it } from 'vitest'
-import { createTenantConfigResolver } from '../../src/config/tenantConfigResolver'
-import { configTemplate } from '../../src/config/configTemplate'
-import { createProjectConfigResolver } from '../../src/config/projectConfigResolver'
-
-const env = {
-	DEFAULT_DB_POOL_IDLE_TIMEOUT_MS: '60000',
-	DEFAULT_DB_POOL_MAX_CONNECTIONS: '1000',
-	DEFAULT_DB_POOL_MAX_CONNECTING: '10',
-	DEFAULT_DB_CONNECTION_TIMEOUT_MS: '5000',
-}
-const tenantConfig = {
-	db: {
-		host: 'c0.cluster-abc.eu-west-1.rds.amazonaws.com',
-		port: 5432,
-		user: 'u_test_e',
-		password: 'PASSWD',
-		database: 'p_test_e',
-		read: { host: 'c0.cluster-ro-abc.eu-west-1.rds.amazonaws.com' },
-	},
-}
-it('resolves tenant config config', () => {
-	const tenantResolver = createTenantConfigResolver(env, configTemplate.tenant)
-	const resolvedTenantConfig = tenantResolver('test', tenantConfig)
-	assert.deepEqual(resolvedTenantConfig, {
-		db: {
-			host: 'c0.cluster-abc.eu-west-1.rds.amazonaws.com',
-			port: 5432,
-			user: 'u_test_e',
-			password: 'PASSWD',
-			database: 'p_test_e',
-			connectionTimeoutMs: 5000,
-			pool: { maxConnections: 1000, maxConnecting: 10, idleTimeoutMs: 60000 },
-			read: { host: 'c0.cluster-ro-abc.eu-west-1.rds.amazonaws.com' },
-		}, mailer: {}, credentials: {}, secrets: {},
-	})
-})
-it('resolves project config config', () => {
-	const tenantResolver = createTenantConfigResolver(env, configTemplate.tenant)
-	const resolvedTenantConfig = tenantResolver('test', tenantConfig)
-
-	const projectConfigResolver = createProjectConfigResolver(env, configTemplate, [])
-	const resolvedProjectConfig = projectConfigResolver('test-p', {
-		db: {
-			useTenantDb: true,
-			systemSchema: 'system_test_e',
-		}, s3: { prefix: 'test-e/test-e' }, stages: { live: { schema: 'content_test_e_live' } },
-	}, {}, resolvedTenantConfig)
-
-	assert.deepEqual(resolvedProjectConfig as any, {
-		name: 'Test p',
-		slug: 'test-p',
-		stages: [{ name: 'Live', slug: 'live', schema: 'content_test_e_live' }],
-		db: {
-			host: 'c0.cluster-abc.eu-west-1.rds.amazonaws.com',
-			port: 5432,
-			user: 'u_test_e',
-			password: 'PASSWD',
-			database: 'p_test_e',
-			connectionTimeoutMs: 5000,
-			pool: { maxConnections: 1000, maxConnecting: 10, idleTimeoutMs: 60000 },
-			read: { host: 'c0.cluster-ro-abc.eu-west-1.rds.amazonaws.com' },
-			useTenantDb: true,
-			systemSchema: 'system_test_e',
-		},
-	})
-})