@contember/engine-system-api 1.2.0-alpha.15 → 1.2.0-alpha.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-system-api",
-  "version": "1.2.0-alpha.15",
+  "version": "1.2.0-alpha.16",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -9,22 +9,22 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@contember/authorization": "^1.2.0-alpha.15",
-    "@contember/database": "^1.2.0-alpha.15",
-    "@contember/database-migrations": "^1.2.0-alpha.15",
-    "@contember/dic": "^1.2.0-alpha.15",
-    "@contember/engine-common": "^1.2.0-alpha.15",
-    "@contember/graphql-utils": "^1.2.0-alpha.15",
-    "@contember/queryable": "^1.2.0-alpha.15",
-    "@contember/schema": "^1.2.0-alpha.15",
-    "@contember/schema-migrations": "^1.2.0-alpha.15",
-    "@contember/schema-utils": "^1.2.0-alpha.15",
+    "@contember/authorization": "^1.2.0-alpha.16",
+    "@contember/database": "^1.2.0-alpha.16",
+    "@contember/database-migrations": "^1.2.0-alpha.16",
+    "@contember/dic": "^1.2.0-alpha.16",
+    "@contember/engine-common": "^1.2.0-alpha.16",
+    "@contember/graphql-utils": "^1.2.0-alpha.16",
+    "@contember/queryable": "^1.2.0-alpha.16",
+    "@contember/schema": "^1.2.0-alpha.16",
+    "@contember/schema-migrations": "^1.2.0-alpha.16",
+    "@contember/schema-utils": "^1.2.0-alpha.16",
     "@graphql-tools/utils": "^8.6.13",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/engine-api-tester": "^1.2.0-alpha.15",
-    "@contember/schema-definition": "^1.2.0-alpha.15",
+    "@contember/engine-api-tester": "^1.2.0-alpha.16",
+    "@contember/schema-definition": "^1.2.0-alpha.16",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/SystemContainer.ts

@@ -118,7 +118,7 @@ export class SystemContainerFactory {
 				new EventOldValuesResolver())
 			.addService('systemResolversFactory', ({ stagesQueryResolver, executedMigrationsQueryResolver, migrateMutationResolver, truncateMutationResolver, migrationAlterMutationResolver, eventsQueryResolver, eventOldValuesResolver }) =>
 				new ResolverFactory(stagesQueryResolver, executedMigrationsQueryResolver, migrateMutationResolver, truncateMutationResolver, migrationAlterMutationResolver, eventsQueryResolver, eventOldValuesResolver))
-			.addService('resolverContextFactory', ({ authorizator, schemaVersionBuilder }) =>
-				new SystemResolverContextFactory(authorizator, schemaVersionBuilder))
+			.addService('resolverContextFactory', ({ authorizator }) =>
+				new SystemResolverContextFactory(authorizator))
 	}
 }

package/src/model/ProjectInitializer.ts

@@ -8,9 +8,10 @@ import {
 	Connection,
 	createDatabaseIfNotExists,
 	DatabaseConfig,
+	EventManager,
 	retryTransaction,
 } from '@contember/database'
-import { Logger } from '@contember/engine-common'
+import { FingerCrossedLoggerHandler, Logger } from '@contember/logger'
 
 export class ProjectInitializer {
 	constructor(
@@ -26,54 +27,54 @@ export class ProjectInitializer {
 		logger: Logger,
 	) {
 		const dbContext = databaseContextFactory.create()
-		if (project.db) {
-			// todo: use dbContext
-			logger.group(`Executing system schema migration`)
-			await createDatabaseIfNotExists(project.db, logger.write.bind(logger))
-			const singleConnection = Connection.createSingle(project.db)
-			await singleConnection.scope(async connection => {
-				const systemSchema = dbContext.client.schema
+		return await logger.scope(async initLogger => {
+			if (project.db) {
+				// todo: use dbContext
+				initLogger.debug('Executing system schema migrations')
+				await createDatabaseIfNotExists(project.db, message => typeof message === 'string' ? initLogger.warn(message) : initLogger.error(message))
+				const singleConnection = Connection.createSingle(project.db, err => initLogger.error(err))
+				singleConnection.eventManager.on(EventManager.Event.clientError, err => logger.error(err, { message: 'Database client error' }))
 
-				const schemaResolver = (connection: Connection.ConnectionLike) => {
-					const dbContextMigrations = databaseContextFactory
-						.withClient(new Client(connection, systemSchema, { module: 'system' }))
-						.create()
-					return this.schemaVersionBuilder.buildSchema(dbContextMigrations)
-				}
-				await this.systemDbMigrationsRunnerFactory(connection, systemSchema).migrate(
-					logger.write.bind(logger),
-					{
-						schemaResolver,
-						project,
-					},
-				)
-			})
-			await singleConnection.end()
-			logger.groupEnd()
-		}
-		await retryTransaction(() =>
-			dbContext.transaction(async trx => {
-				await this.initStages(trx, project, logger)
-			}),
-		)
-		if (dbContext.client.connection instanceof Connection) {
-			await dbContext.client.connection.clearPool()
-		}
+				await singleConnection.scope(async connection => {
+					const systemSchema = dbContext.client.schema
+
+					const schemaResolver = (connection: Connection.ConnectionLike) => {
+						const dbContextMigrations = databaseContextFactory
+							.withClient(new Client(connection, systemSchema, { module: 'system' }))
+							.create()
+						return this.schemaVersionBuilder.buildSchema(dbContextMigrations)
+					}
+					await this.systemDbMigrationsRunnerFactory(connection, systemSchema).migrate(
+						message => initLogger.warn(message),
+						{
+							schemaResolver,
+							project,
+						},
+					)
+				})
+				await singleConnection.end()
+			}
+			await retryTransaction(() =>
+				dbContext.transaction(async trx => {
+					await this.initStages(trx, project, initLogger)
+				}),
+			message => initLogger.warn(message),
+			)
+			if (dbContext.client.connection instanceof Connection) {
+				await dbContext.client.connection.clearPool()
+			}
+		}, {}, { handler: FingerCrossedLoggerHandler.factory() })
 	}
 
 	private async initStages(db: DatabaseContext<Connection.TransactionLike>, project: ProjectConfig, logger: Logger) {
-
-		logger.group(`Creating stages`)
-
+		logger.debug(`Creating stages`)
 		for (const stage of project.stages) {
 			const created = await this.stageCreator.createStage(db, stage)
 			if (created) {
-				logger.write(`Created stage ${stage.slug} `)
+				logger.warn(`Created stage ${stage.slug}`, { stage: stage.slug })
 			} else {
-				logger.breadcrumb(`Updated stage ${stage.slug}`)
+				logger.debug(`Updated stage ${stage.slug}`, { stage: stage.slug })
 			}
 		}
-
-		logger.groupEnd()
 	}
 }

package/src/model/migrations/ProjectMigrator.ts

@@ -8,6 +8,7 @@ import { ExecutedMigrationsResolver } from './ExecutedMigrationsResolver'
 import { MigrateErrorCode } from '../../schema'
 import { SchemaVersionBuilder } from './SchemaVersionBuilder'
 import { SchemaValidator } from '@contember/schema-utils'
+import { logger } from '@contember/logger'
 
 export class ProjectMigrator {
 	constructor(
@@ -120,8 +121,7 @@ export class ProjectMigrator {
 			await db.query(sql)
 		} catch (e) {
 			if (e instanceof QueryError) {
-				// eslint-disable-next-line no-console
-				console.error(e)
+				logger.error(e, { message: 'Migration failed' })
 				throw new MigrationFailedError(migrationVersion, e.message)
 			}
 			throw e

package/src/resolvers/SystemResolverContext.ts

@@ -10,15 +10,14 @@ import { ItemLoader } from '../utils/batchQuery'
 export class SystemResolverContextFactory {
 	constructor(
 		private readonly authorizator: Authorizator<Identity>,
-		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 	) {}
 
 	public async create(
+		schema: Schema,
 		systemDbContext: DatabaseContext,
 		project: ProjectConfig,
 		identity: Identity,
 	): Promise<SystemResolverContext> {
-		const schema = await this.schemaVersionBuilder.buildSchema(systemDbContext)
 		const stagePermissionsFactory = new StagePermissionsFactory(schema)
 		const loaders = new Map<LoaderFactory<any, any>, ItemLoader<any, any>>()
 		return {

package/tests/cases/integration/systemApi/projectInitializer.test.ts

@@ -1,10 +1,10 @@
 import { ApiTester } from '@contember/engine-api-tester'
 import { ProjectConfig, StageConfig } from '../../../../src'
 import { assert, test } from 'vitest'
+import { createLogger, JsonStreamLoggerHandler } from '@contember/logger'
 
-import { Logger } from '@contember/engine-common'
 
-const nullLogger = new Logger(() => {})
+const logger = createLogger(new JsonStreamLoggerHandler(process.stderr))
 
 test('create stage', async () => {
 	const prodStage: StageConfig = {
@@ -22,7 +22,7 @@ test('create stage', async () => {
 		},
 	})
 
-	await tester.systemContainer.projectInitializer.initialize(tester.databaseContextFactory, project, nullLogger)
+	await tester.systemContainer.projectInitializer.initialize(tester.databaseContextFactory, project, logger)
 	const createdStagesA = await tester.stages.refreshCreatedStages()
 	assert.ok(createdStagesA.has('prod'))