@contember/engine-system-api 1.2.0-alpha.9 → 1.2.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-system-api",
-  "version": "1.2.0-alpha.9",
+  "version": "1.2.0-beta.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -9,22 +9,23 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@contember/authorization": "^1.2.0-alpha.9",
-    "@contember/database": "^1.2.0-alpha.9",
-    "@contember/database-migrations": "^1.2.0-alpha.9",
-    "@contember/dic": "^1.2.0-alpha.9",
-    "@contember/engine-common": "^1.2.0-alpha.9",
-    "@contember/graphql-utils": "^1.2.0-alpha.9",
-    "@contember/queryable": "^1.2.0-alpha.9",
-    "@contember/schema": "^1.2.0-alpha.9",
-    "@contember/schema-migrations": "^1.2.0-alpha.9",
-    "@contember/schema-utils": "^1.2.0-alpha.9",
+    "@contember/authorization": "^1.2.0-beta.1",
+    "@contember/database": "^1.2.0-beta.1",
+    "@contember/database-migrations": "^1.2.0-beta.1",
+    "@contember/dic": "^1.2.0-beta.1",
+    "@contember/engine-common": "^1.2.0-beta.1",
+    "@contember/graphql-utils": "^1.2.0-beta.1",
+    "@contember/logger": "^1.2.0-beta.1",
+    "@contember/queryable": "^1.2.0-beta.1",
+    "@contember/schema": "^1.2.0-beta.1",
+    "@contember/schema-migrations": "^1.2.0-beta.1",
+    "@contember/schema-utils": "^1.2.0-beta.1",
     "@graphql-tools/utils": "^8.6.13",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/engine-api-tester": "^1.2.0-alpha.9",
-    "@contember/schema-definition": "^1.2.0-alpha.9",
+    "@contember/engine-api-tester": "^1.2.0-beta.1",
+    "@contember/schema-definition": "^1.2.0-beta.1",
     "@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/migrations/2020-05-06-150000-composed-primary.ts

@@ -1,7 +1,7 @@
 import { escapeValue, MigrationBuilder, Name } from '@contember/database-migrations'
 import { SystemMigrationArgs } from './types'
 import { getJunctionTables } from '../model'
-import { MigrationArgs } from '@contember/database-migrations/dist/src/Migration'
+import { MigrationArgs } from '@contember/database-migrations'
 
 const createEventTrigger = (builder: MigrationBuilder, tableName: Name, primaryColumns: string[]) => {
 	builder.createTrigger(tableName, 'log_event', {

package/src/migrations/2020-06-01-103000-event-trigger-perf.ts

@@ -1,7 +1,7 @@
 import { MigrationBuilder, Name } from '@contember/database-migrations'
 import { SystemMigrationArgs } from './types'
 import { getJunctionTables } from '../model'
-import { MigrationArgs } from '@contember/database-migrations/dist/src/Migration'
+import { MigrationArgs } from '@contember/database-migrations'
 
 const createEventStatementTrigger = (builder: MigrationBuilder, tableName: Name) => {
 	builder.createTrigger(tableName, 'log_event_statement', {

package/src/migrations/2021-05-07-155800-event-log-rework.ts

@@ -1,7 +1,7 @@
 import { MigrationBuilder, Name } from '@contember/database-migrations'
 import { SystemMigrationArgs } from './types'
 import { getJunctionTables } from '../model'
-import { MigrationArgs } from '@contember/database-migrations/dist/src/Migration'
+import { MigrationArgs } from '@contember/database-migrations'
 
 const createTrxEvent = (builder: MigrationBuilder, tableName: Name) => {
 	builder.createTrigger(tableName, 'log_event_trx', {

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,53 @@ 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, { 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/helpers/modelHelpers.ts

@@ -5,7 +5,7 @@ export const getJunctionTables = (model: Model.Schema): Model.JoiningTable[] =>
 	const tables: Model.JoiningTable[] = []
 	Object.values(model.entities).forEach(entity => {
 		acceptEveryFieldVisitor(model, entity, {
-			visitManyHasManyOwning: ({}, relation) => {
+			visitManyHasManyOwning: ({ relation }) => {
 				tables.push(relation.joiningTable)
 			},
 			visitColumn: () => {},

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(
@@ -81,16 +82,25 @@ export class ProjectMigrator {
 			}
 			const latestModification = described[described.length - 1]
 			schema = latestModification.schema
-			const errors = SchemaValidator.validate(schema)
+			const errors = SchemaValidator.validate(schema, migration.skippedErrors)
 			if (errors.length > 0) {
 				throw new InvalidSchemaError(
 					migration.version,
 					'Migration generates invalid schema: \n' +
-					errors.map(it => it.path.join('.') + ': ' + it.message).join('\n'),
+					errors.map(it => `${it.path.join('.')}: [${it.code}] ${it.message}`).join('\n'),
 				)
 			}
 			toExecute.push(migration)
 		}
+		// intentionally not using skippedErrors here
+		const errors = SchemaValidator.validate(schema)
+		if (errors.length > 0) {
+			throw new InvalidSchemaError(
+				toExecute[toExecute.length - 1].version,
+				'Migration generates invalid schema: \n' +
+				errors.map(it => it.path.join('.') + ': ' + it.message).join('\n'),
+			)
+		}
 		return toExecute
 	}
 
@@ -120,8 +130,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/model/queries/events/LatestTransactionIdByStageQuery.ts

@@ -1,34 +1,20 @@
-import { DatabaseQuery, DatabaseQueryable } from '@contember/database'
+import { DatabaseQuery, DatabaseQueryable, SelectBuilder } from '@contember/database'
 import { ImplementationException } from '../../../utils'
 
 export class LatestTransactionIdByStageQuery extends DatabaseQuery<string> {
-	constructor(private readonly stageSlug: string) {
+	constructor(private readonly stageId: string) {
 		super()
 	}
 
 	async fetch(queryable: DatabaseQueryable): Promise<string> {
-		const stageId = (
-			await queryable.db.query<{ id: string }>(
-				`
-				SELECT id
-				FROM system.stage
-				WHERE slug = ?
-				`,
-				[this.stageSlug],
-			)
-		).rows[0].id
-		const rows = (
-			await queryable.db.query<{ transaction_id: string }>(
-				`
-				SELECT transaction_id
-				FROM system.stage_transaction
-				WHERE stage_id = ?
-				ORDER BY applied_at DESC
-				LIMIT 1
-				`,
-				[stageId],
-			)
-		).rows
+		const rows = await SelectBuilder.create<{ transaction_id: string }>()
+			.from('stage_transaction')
+			.select('transaction_id')
+			.where({ stage_id: this.stageId })
+			.orderBy('applied_at', 'desc')
+			.limit(1)
+			.getResult(queryable.db)
+
 		if (rows.length !== 1) {
 			throw new ImplementationException()
 		}

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/src/schema/system.graphql.ts

@@ -139,6 +139,12 @@ const schema: DocumentNode = gql`
 		name: String!
 		formatVersion: Int!
 		modifications: [Json!]!
+		skippedErrors: [MigrationSkippedError!]
+	}
+
+	input MigrationSkippedError {
+		code: String!
+		path: String
 	}
 
 	enum MigrateErrorCode {

package/src/schema/types.ts

@@ -145,6 +145,7 @@ export type Migration = {
 	readonly formatVersion: Scalars['Int']
 	readonly modifications: ReadonlyArray<Scalars['Json']>
 	readonly name: Scalars['String']
+	readonly skippedErrors?: InputMaybe<ReadonlyArray<MigrationSkippedError>>
 	readonly version: Scalars['String']
 }
 
@@ -188,6 +189,11 @@ export type MigrationModifyResponse = {
 	readonly ok: Scalars['Boolean']
 }
 
+export type MigrationSkippedError = {
+	readonly code: Scalars['String']
+	readonly path?: InputMaybe<Scalars['String']>
+}
+
 export type Mutation = {
 	readonly __typename?: 'Mutation'
 	readonly forceMigrate: MigrateResponse
@@ -358,6 +364,7 @@ export type ResolversTypes = {
 	MigrationModifyError: ResolverTypeWrapper<MigrationModifyError>
 	MigrationModifyErrorCode: MigrationModifyErrorCode
 	MigrationModifyResponse: ResolverTypeWrapper<MigrationModifyResponse>
+	MigrationSkippedError: MigrationSkippedError
 	Mutation: ResolverTypeWrapper<{}>
 	PrimaryKey: ResolverTypeWrapper<Scalars['PrimaryKey']>
 	Query: ResolverTypeWrapper<{}>
@@ -390,6 +397,7 @@ export type ResolversParentTypes = {
 	MigrationModification: MigrationModification
 	MigrationModifyError: MigrationModifyError
 	MigrationModifyResponse: MigrationModifyResponse
+	MigrationSkippedError: MigrationSkippedError
 	Mutation: {}
 	PrimaryKey: Scalars['PrimaryKey']
 	Query: {}

package/src/tsconfig.json

@@ -6,7 +6,7 @@
 	},
 	"references": [
 		{
-			"path": "../../queryable/src"
+			"path": "../../authorization/src"
 		},
 		{
 			"path": "../../database/src"
@@ -14,15 +14,18 @@
 		{
 			"path": "../../database-migrations/src"
 		},
-		{
-			"path": "../../authorization/src"
-		},
 		{
 			"path": "../../engine-common/src"
 		},
 		{
 			"path": "../../graphql-utils/src"
 		},
+		{
+			"path": "../../logger/src"
+		},
+		{
+			"path": "../../queryable/src"
+		},
 		{
 			"path": "../../schema/src"
 		},

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'))