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

package/dist/src/utils/tuple.d.ts

@@ -1,2 +0,0 @@
-export declare const tuple: <T extends unknown[]>(...args: T) => T;
-//# sourceMappingURL=tuple.d.ts.map

package/dist/src/utils/tuple.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../../src/utils/tuple.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,wCAA4C,CAAA"}

package/dist/src/utils/tuple.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tuple = void 0;
-const tuple = (...args) => args;
-exports.tuple = tuple;
-//# sourceMappingURL=tuple.js.map

package/dist/src/utils/tuple.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tuple.js","sourceRoot":"","sources":["../../../src/utils/tuple.ts"],"names":[],"mappings":";;;AAAO,MAAM,KAAK,GAAG,CAAsB,GAAG,IAAO,EAAE,EAAE,CAAC,IAAI,CAAA;AAAjD,QAAA,KAAK,SAA4C"}

package/jasmine.json

@@ -1,7 +0,0 @@
-{
-	"spec_files": [
-		"dist/tests/cases/**/*.js"
-	],
-	"stopSpecOnExpectationFailure": false,
-	"random": false
-}

package/src/http/CollectHttpMetricsMiddelware.ts

@@ -1,32 +0,0 @@
-import { KoaMiddleware, ModuleInfoMiddlewareState, ProjectInfoMiddlewareState } from '@contember/engine-http'
-import prom from 'prom-client'
-import { GraphQLKoaState } from '@contember/engine-http'
-
-export const createColllectHttpMetricsMiddleware = (
-	registry: prom.Registry,
-): KoaMiddleware<Partial<ProjectInfoMiddlewareState & ModuleInfoMiddlewareState & GraphQLKoaState>> => {
-	const requestSummary = new prom.Histogram({
-		name: 'contember_http_duration_seconds',
-		help: 'Incoming HTTP requests statistics by http_method (OPTIONS requests are ignored), http_code, contember_project (or "unknown" for undefined project), contember_project_group (or "unknown" for undefined project group), contember_module (system, tenant, content, unknown) and graphql_operation (query, mutation, unknown)',
-		registers: [registry],
-		labelNames: ['http_method', 'http_code', 'contember_project', 'contember_project_group', 'contember_module', 'graphql_operation'],
-		buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
-	})
-
-	return async (ctx, next) => {
-		const end = ctx.method === 'OPTIONS' ? () => null : requestSummary.startTimer()
-		try {
-			await next()
-		} finally {
-			const labels = {
-				http_method: ctx.method,
-				http_code: ctx.status,
-				contember_project: ctx.state.project || 'unknown',
-				contember_project_group: ctx.state.projectGroup || 'unknown',
-				contember_module: ctx.state.module || 'unknown',
-				graphql_operation: ctx.state.graphql?.operationName || 'unknown',
-			}
-			end(labels)
-		}
-	}
-}

package/src/http/ShowMetricsMiddleware.ts

@@ -1,12 +0,0 @@
-import { KoaMiddleware, route } from '@contember/engine-http'
-import prom from 'prom-client'
-
-export const createShowMetricsMiddleware = (registry: prom.Registry): KoaMiddleware<any> => {
-	return route('/metrics', async ctx => {
-		if (registry instanceof prom.AggregatorRegistry) {
-			ctx.body = await registry.clusterMetrics()
-		} else {
-			ctx.body = registry.metrics()
-		}
-	})
-}

package/src/http/index.ts

@@ -1,2 +0,0 @@
-export * from './CollectHttpMetricsMiddelware'
-export * from './ShowMetricsMiddleware'

package/src/projectGroup/ProjectGroupContainerResolver.ts

@@ -1,47 +0,0 @@
-import { TenantConfigResolver } from '../config/tenantConfigResolver'
-import {
-	ProjectGroupContainer,
-	ProjectGroupContainerResolver as ProjectGroupContainerResolverInterface,
-} from '@contember/engine-http'
-import { ProjectGroupContainerFactory } from './ProjectGroupContainer'
-import { PromiseMap } from '@contember/engine-common'
-import { isDeepStrictEqual } from 'util'
-
-interface ContainerWithMeta {
-	container: ProjectGroupContainer
-	cleanups: (() => void)[]
-	inputConfig: any
-}
-
-export class ProjectGroupContainerResolver implements ProjectGroupContainerResolverInterface {
-	private containers = new PromiseMap<string | undefined, ContainerWithMeta>()
-
-	public readonly onCreate: ((container: ProjectGroupContainer, slug: string | undefined) => void | (() => void))[] = []
-
-	constructor(
-		private readonly configResolver: TenantConfigResolver,
-		private readonly containerFactory: ProjectGroupContainerFactory,
-	) {}
-
-	public async getProjectGroupContainer(slug: string | undefined, config: any = {}): Promise<ProjectGroupContainer> {
-		const existing = this.containers.get(slug)
-		if (existing) {
-			const existingAwaited = await existing
-			if (isDeepStrictEqual(config, existingAwaited.inputConfig)) {
-				return existingAwaited.container
-			}
-			existingAwaited.cleanups.forEach(it => it())
-			this.containers.delete(slug)
-		}
-		return (await this.containers.fetch(slug, async slug => {
-			const container = this.containerFactory.create({
-				config: this.configResolver(slug, config),
-				slug,
-			})
-			const cleanups = this.onCreate.map(it => it(container, slug) || (() => null))
-			// eslint-disable-next-line no-console
-			await container.tenantContainer.migrationsRunner.run(console.log)
-			return { container, inputConfig: config, cleanups }
-		})).container
-	}
-}

package/src/utils/cluster.ts

@@ -1,40 +0,0 @@
-import cluster from 'cluster'
-import { timeout } from './timeout'
-
-export const getClusterProcessType = (isClusterMode: boolean) =>
-	!isClusterMode ? ProcessType.singleNode : cluster.isMaster ? ProcessType.clusterMaster : ProcessType.clusterWorker
-
-export enum ProcessType {
-	singleNode,
-	clusterMaster,
-	clusterWorker,
-}
-
-const MSG_WORKER_STARTED = 'msg_worker_started'
-
-export const waitForWorker = (timeoutMs: number) => {
-	let ok = false
-	return Promise.race([
-		new Promise(async resolve => {
-			const listener = ({}, message: any) => {
-				if ('type' in message && message.type === MSG_WORKER_STARTED) {
-					ok = true
-					resolve(null)
-					cluster.removeListener('message', listener)
-				}
-			}
-			await cluster.on('message', listener)
-		}),
-		timeout(timeoutMs).then(() => {
-			if (!ok) {
-				throw new Error('Worker start timed out')
-			}
-			return true
-		}),
-	])
-}
-
-export const notifyWorkerStarted = () =>
-	process.send?.({
-		type: MSG_WORKER_STARTED,
-	})

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/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": []
-}