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

package/src/utils/dbMetrics.ts

@@ -1,111 +0,0 @@
-import prom from 'prom-client'
-import { Connection, EventManager } from '@contember/database'
-
-const labelNames = ['contember_project' as const, 'contember_module' as const, 'contember_project_group' as const]
-type LabelNames = typeof labelNames[number]
-type Labels = { [K in LabelNames]: string }
-type DatabaseMetricsEntry = {
-	connection: Connection.PoolStatusProvider & Connection.Queryable
-	labels: Labels
-}
-type Unregistrar = () => void
-type DatabaseMetricsRegistrar = (entry: DatabaseMetricsEntry) => Unregistrar
-
-export const createDbMetricsRegistrar = (registry: prom.Registry): DatabaseMetricsRegistrar => {
-	const dbPoolCollectorInner = createSingleDbPoolMetricsCollector(registry)
-	const entries = new Set<DatabaseMetricsEntry>()
-	const collector = () => {
-		for (const entry of entries) {
-			dbPoolCollectorInner(entry.connection, entry.labels)
-		}
-	}
-	registry.registerCollector(collector)
-	const sqlMetricsRegistrar = createSqlMetricsRegistrar(registry)
-	return entry => {
-		entries.add(entry)
-		const sqlMetricsUnregistrar = sqlMetricsRegistrar(entry.connection, entry.labels)
-		return () => {
-			entries.delete(entry)
-			sqlMetricsUnregistrar()
-		}
-	}
-}
-
-const createSingleDbPoolMetricsCollector = (registry: prom.Registry) => {
-
-	const totalCount = new prom.Gauge({
-		registers: [registry],
-		name: `contember_db_pool_total_count`,
-		help: 'The total number of clients existing within the pool by contember_module (tenant or content; system is not used since it uses the same connection) and contember_project for contember_module=content.',
-		labelNames,
-	})
-	const idleCount = new prom.Gauge({
-		registers: [registry],
-		name: `contember_db_pool_idle_count`,
-		help: 'The number of clients which are not checked out but are currently idle in the pool by contember_module (tenant or content; system is not used since it uses the same connection) and contember_project for contember_module=content.',
-		labelNames,
-	})
-	const waitingCount = new prom.Gauge({
-		registers: [registry],
-		name: `contember_db_pool_waiting_count`,
-		help: 'The number of queued requests waiting on a client when all clients are checked out. It can be helpful to monitor this number to see if you need to adjust the size of the pool by contember_module (tenant or content; system is not used since it uses the same connection) and contember_project for contember_module=content.',
-		labelNames,
-	})
-	const maxCount = new prom.Gauge({
-		registers: [registry],
-		name: `contember_db_pool_max_count`,
-		help: 'Maximum number of clients the pool should contain by contember_module (tenant or content; system is not used since it uses the same connection) and contember_project for contember_module=content.',
-		labelNames,
-	})
-
-	return (db: Connection.PoolStatusProvider, labels: Labels) => {
-		const poolInfo = db.getPoolStatus()
-		totalCount.set(labels, poolInfo.totalCount)
-		idleCount.set(labels, poolInfo.idleCount)
-		waitingCount.set(labels, poolInfo.waitingCount)
-		maxCount.set(labels, poolInfo.maxCount)
-	}
-}
-type SqlMetricsRegistrar = (
-	connection: Connection.Queryable,
-	labels: Labels,
-) => Unregistrar
-const createSqlMetricsRegistrar = (registry: prom.Registry): SqlMetricsRegistrar => {
-	const sqlDuration = new prom.Histogram({
-		name: 'contember_sql_duration_ms',
-		help: 'Executed SQL queries by contember_module (system, tenant, content or unknown) and contember_project (or "unknown" for unknown project)',
-		registers: [registry],
-		labelNames,
-		buckets: [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000],
-	})
-	const sqlErrorRate = new prom.Counter({
-		name: 'contember_sql_error_count',
-		help: 'Failed SQL queries by contember_module (system, tenant, content or unknown) and contember_project (or "unknown" for unknown project)',
-		labelNames,
-		registers: [registry],
-	})
-
-	return (connection, labels) => {
-		const queryEndCallback: EventManager.ListenerTypes[EventManager.Event.queryEnd] = ({ meta }, { timing }) => {
-			sqlDuration.observe(
-				{
-					...labels,
-					contember_module: meta.module || labels.contember_module,
-				},
-				timing ? timing.selfDuration / 1000 : 0,
-			)
-		}
-		const queryErrorCallback: EventManager.ListenerTypes[EventManager.Event.queryError] = ({ meta }) => {
-			sqlErrorRate.inc({
-				...labels,
-				contember_module: meta.module || labels.contember_module,
-			})
-		}
-		connection.eventManager.on(EventManager.Event.queryEnd, queryEndCallback)
-		connection.eventManager.on(EventManager.Event.queryError, queryErrorCallback)
-		return () => {
-			connection.eventManager.removeListener(EventManager.Event.queryEnd, queryEndCallback)
-			connection.eventManager.removeListener(EventManager.Event.queryError, queryErrorCallback)
-		}
-	}
-}

package/src/utils/timeout.ts

@@ -1,4 +0,0 @@
-export const timeout = (ms: number) =>
-	new Promise(resolve => {
-		setTimeout(resolve, ms)
-	})

package/src/utils/tuple.ts

@@ -1 +0,0 @@
-export const tuple = <T extends unknown[]>(...args: T) => args

package/tests/e2e/http.test.ts

@@ -1,303 +0,0 @@
-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'
-
-
-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('/')
-		.expect(200)
-		.expect('App is running')
-})
-
-test('Content API: create & read tag', async () => {
-	await executeGraphql(
-		gql`
-			mutation {
-				createTag(data: { label: "graphql" }) {
-					ok
-				}
-			}
-		`,
-	)
-		.expect(response => {
-			assert.deepStrictEqual(response.body.data, {
-				createTag: {
-					ok: true,
-				},
-			})
-		})
-		.expect(200)
-
-	await executeGraphql(
-		gql`
-			query {
-				listTag(filter: { label: { eq: "graphql" } }) {
-					label
-				}
-			}
-		`,
-	)
-		.expect(response => {
-			assert.deepStrictEqual(response.body.data, {
-				listTag: [
-					{
-						label: 'graphql',
-					},
-				],
-			})
-		})
-		.expect(200)
-})
-
-test('Content API: X-Contember-Ref header', async () => {
-	await executeGraphql(
-		gql`
-			mutation {
-				createTag(data: { label: "typescript" }) {
-					ok
-				}
-			}
-		`,
-	).expect(200)
-
-	const response = await executeGraphql(
-		gql`
-			query {
-				listTag(filter: { label: { eq: "typescript" } }) {
-					label
-				}
-			}
-		`,
-	)
-		.set('X-Contember-Ref', 'None')
-		.expect(response => {
-			assert.deepStrictEqual(response.body.data, {
-				listTag: [
-					{
-						label: 'typescript',
-					},
-				],
-			})
-		})
-		.expect(200)
-	const eventKey = response.get('X-Contember-Ref')
-	await executeGraphql(
-		gql`
-			query {
-				listTag {
-					label
-				}
-			}
-		`,
-	)
-		.set('X-Contember-Ref', eventKey)
-		.expect(304)
-
-	// ignored for mutation
-	await executeGraphql(
-		gql`
-			mutation {
-				createTag(data: { label: "typescript" }) {
-					ok
-				}
-			}
-		`,
-	)
-		.set('X-Contember-Ref', eventKey)
-		.expect(200)
-})
-
-test('Content API: invalid schema error', async () => {
-	await executeGraphql(
-		gql`
-			mutation {
-				createFoo(data: { label: "graphql" }) {
-					ok
-				}
-			}
-		`,
-	)
-		.expect(400)
-		.expect(response => {
-			assert.deepStrictEqual(
-				response.body.errors[0].message,
-				'Cannot query field "createFoo" on type "Mutation". Did you mean "createPost" or "createTag"?',
-			)
-		})
-})
-
-test('Tenant API: sign up, add to a project and check project access', async () => {
-	const email = `john+${Date.now()}@doe.com`
-	const signUpResponse = await executeGraphql(
-		gql`
-			mutation($email: String!) {
-				signUp(email: $email, password: "123456") {
-					ok
-					result {
-						person {
-							identity {
-								id
-							}
-						}
-					}
-				}
-			}
-		`,
-		{
-			path: '/tenant',
-			variables: { email },
-		},
-	).expect(200)
-
-	const identityId = signUpResponse.body.data.signUp.result.person.identity.id
-
-	const authKey = await signIn(email, '123456')
-	await executeGraphql(
-		gql`
-			query {
-				listTag {
-					id
-				}
-			}
-		`,
-		{ authorizationToken: authKey },
-	)
-		.expect(404)
-		.expect({ errors: [{ message: `Project ${projectSlug} NOT found`, code: 404 }] })
-
-	await executeGraphql(
-		gql`
-			mutation ($identity: String!, $projectSlug: String!) {
-				addProjectMember(identityId: $identity, projectSlug: $projectSlug, memberships: [{ role: "admin", variables: [] }]) {
-					ok
-				}
-			}
-		`,
-		{ path: '/tenant', variables: { identity: identityId, projectSlug } },
-	)
-		.expect(200)
-		.expect(response => {
-			assert.deepStrictEqual(response.body.data, { addProjectMember: { ok: true } })
-		})
-
-	await executeGraphql(
-		gql`
-			query {
-				listAuthor {
-					id
-				}
-			}
-		`,
-		{ authorizationToken: authKey },
-	)
-		.expect(response => {
-			assert.deepStrictEqual(response.body.data, { listAuthor: [] })
-		})
-		.expect(200)
-})

package/tslint.json

@@ -1,14 +0,0 @@
-{
-	"defaultSeverity": "error",
-	"extends": ["tslint:recommended"],
-	"jsRules": {},
-	"rules": {
-		"interface-name": [true, "never-prefix"],
-		"object-literal-sort-keys": [false],
-		"trailing-comma": [false],
-		"semicolon": [true, "never"],
-		"arrow-parens": [true, "ban-single-arg-parens"],
-		"one-line": [true, "check-catch", "check-finally", "check-else"]
-	},
-	"rulesDirectory": []
-}