@contember/engine-system-api 1.4.0-alpha.1 → 1.4.0-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-system-api",
-  "version": "1.4.0-alpha.1",
+  "version": "1.4.0-alpha.3",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -13,29 +13,29 @@
     "test": "vitest --dir ./tests/cases"
   },
   "dependencies": {
-    "@contember/authorization": "1.4.0-alpha.1",
-    "@contember/database": "1.4.0-alpha.1",
-    "@contember/database-migrations": "1.4.0-alpha.1",
-    "@contember/dic": "1.4.0-alpha.1",
-    "@contember/graphql-utils": "1.4.0-alpha.1",
-    "@contember/logger": "1.4.0-alpha.1",
-    "@contember/queryable": "1.4.0-alpha.1",
-    "@contember/schema": "1.4.0-alpha.1",
-    "@contember/schema-migrations": "1.4.0-alpha.1",
-    "@contember/schema-utils": "1.4.0-alpha.1",
-    "@graphql-tools/utils": "^10.0.7",
-    "graphql-tag": "^2.12.5"
+    "@contember/authorization": "1.4.0-alpha.3",
+    "@contember/database": "1.4.0-alpha.3",
+    "@contember/database-migrations": "1.4.0-alpha.3",
+    "@contember/dic": "1.4.0-alpha.3",
+    "@contember/graphql-utils": "1.4.0-alpha.3",
+    "@contember/logger": "1.4.0-alpha.3",
+    "@contember/queryable": "1.4.0-alpha.3",
+    "@contember/schema": "1.4.0-alpha.3",
+    "@contember/schema-migrations": "1.4.0-alpha.3",
+    "@contember/schema-utils": "1.4.0-alpha.3",
+    "@graphql-tools/utils": "^10.0.8",
+    "graphql-tag": "^2.12.6"
   },
   "devDependencies": {
-    "@contember/engine-api-tester": "1.4.0-alpha.1",
-    "@contember/schema-definition": "1.4.0-alpha.1",
-    "@graphql-codegen/cli": "^2.6.2",
-    "@graphql-codegen/typescript": "^2.5.1",
-    "@graphql-codegen/typescript-operations": "^2.4.2",
-    "@graphql-codegen/typescript-resolvers": "^2.6.6",
-    "@types/node": "^18",
-    "graphql": "^16.5.0",
-    "pg": "^8.9.0"
+    "@contember/engine-api-tester": "1.4.0-alpha.3",
+    "@contember/schema-definition": "1.4.0-alpha.3",
+    "@graphql-codegen/cli": "^5.0.0",
+    "@graphql-codegen/typescript": "^4.0.1",
+    "@graphql-codegen/typescript-operations": "^4.0.1",
+    "@graphql-codegen/typescript-resolvers": "^4.0.1",
+    "@types/node": "^20.9.0",
+    "graphql": "^16.8.1",
+    "pg": "^8.11.3"
   },
   "peerDependencies": {
     "graphql": ">= 14.6.0",

package/src/SystemContainer.ts

@@ -7,6 +7,7 @@ import {
 	SchemaMigrator,
 } from '@contember/schema-migrations'
 import {
+	ContentQueryExecutor,
 	EventResponseBuilder,
 	ExecutedMigrationsResolver,
 	IdentityFetcher,
@@ -46,6 +47,7 @@ export class SystemContainerFactory {
 	constructor(
 		private readonly providers: UuidProvider,
 		private readonly modificationHandlerFactory: ModificationHandlerFactory,
+		private readonly contentQueryExecutor: ContentQueryExecutor,
 	) {
 	}
 
@@ -86,7 +88,7 @@ export class SystemContainerFactory {
 			.addService('migrationsDatabaseMetadataResolverStoreFactory', ({ databaseMetadataResolver }) =>
 				new MigrationsDatabaseMetadataResolverStoreFactory(databaseMetadataResolver))
 			.addService('projectMigrator', ({ migrationDescriber, schemaVersionBuilder, executedMigrationsResolver, migrationsDatabaseMetadataResolverStoreFactory }) =>
-				new ProjectMigrator(migrationDescriber, schemaVersionBuilder, executedMigrationsResolver, migrationsDatabaseMetadataResolverStoreFactory))
+				new ProjectMigrator(migrationDescriber, schemaVersionBuilder, executedMigrationsResolver, migrationsDatabaseMetadataResolverStoreFactory, this.contentQueryExecutor))
 			.addService('projectTruncateExecutor', () =>
 				new ProjectTruncateExecutor())
 			.addService('migrationAlterer', () =>

package/src/bin/runMigrations.ts

@@ -18,8 +18,7 @@ import { createLogger, PrettyPrintLoggerHandler } from '@contember/logger'
 				throw new Error()
 			},
 		}),
-		{ db: dbConfig, slug: 'test', stages: [] },
-		'system',
+		{ db: dbConfig, slug: 'test', stages: [], systemSchema: 'system' },
 		{
 			buildSchema: () => Promise.resolve(emptyVersionedSchema),
 		} as unknown as SchemaVersionBuilder,

package/src/index.ts

@@ -1,8 +1,12 @@
-export { SchemaMigrator, MigrationsResolver } from '@contember/schema-migrations'
+export { SchemaMigrator } from '@contember/schema-migrations'
 
 export { typeDefs, devTypeDefs, Schema } from './schema'
 
 export {
+	ContentQueryExecutor,
+	ContentQueryExecutorContext,
+	ContentQueryExecutorQuery,
+	ContentQueryExecutorResult,
 	DatabaseContext,
 	DatabaseContextFactory,
 	Command,

package/src/migrations/2023-10-24-140000-schema-nullable-checksum.ts

@@ -0,0 +1,11 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
+CREATE TYPE SCHEMA_MIGRATION_TYPE AS ENUM('schema', 'content');
+ALTER TABLE schema_migration ALTER checksum DROP NOT NULL,
+ADD COLUMN type SCHEMA_MIGRATION_TYPE NOT NULL DEFAULT 'schema';
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/runner.ts

@@ -1,4 +1,9 @@
-import { MigrationGroup, MigrationsRunner as DbMigrationsRunner } from '@contember/database-migrations'
+import {
+	GroupMigrationsResolver,
+	MigrationGroup,
+	MigrationsRunner as DbMigrationsRunner,
+	SnapshotMigrationResolver,
+} from '@contember/database-migrations'
 import _20180804102200init from './2018-08-04-102200-init'
 import _20180805130501triggereventfunction from './2018-08-05-130501-trigger-event-function'
 import _20190114143432eventtrxid from './2019-01-14-143432-event-trx-id'
@@ -19,14 +24,13 @@ import _20220208144400dynamicstageschema from './2022-02-08-144400-dynamic-stage
 import _20221003110000tableondelete from './2022-10-03-110000-table-on-delete'
 import _20230911174000fixondelete from './2023-09-11-174000-fix-on-delete'
 import _20231019173000fixunique from './2023-10-19-173000-fix-unique'
+import _20231024140000schemanullablechecksum from './2023-10-24-140000-schema-nullable-checksum'
 import snapshot from './snapshot'
 
-import { Client, Connection, createDatabaseIfNotExists, DatabaseConfig, DatabaseMetadataResolver } from '@contember/database'
+import { Connection, createDatabaseIfNotExists, DatabaseConfig, DatabaseMetadataResolver } from '@contember/database'
 import { DatabaseContextFactory, SchemaVersionBuilder } from '../model'
 import { ProjectConfig } from '../types'
 import { Logger } from '@contember/logger'
-import { GroupMigrationsResolver } from '@contember/database-migrations'
-import { SnapshotMigrationResolver } from '@contember/database-migrations'
 
 const migrations = {
 	'2018-08-04-102200-init': _20180804102200init,
@@ -49,6 +53,7 @@ const migrations = {
 	'2022-10-03-110000-table-on-delete': _20221003110000tableondelete,
 	'2023-09-11-174000-fix-on-delete': _20230911174000fixondelete,
 	'2023-10-19-173000-fix-unique': _20231019173000fixunique,
+	'2023-10-24-140000-schema-nullable-checksum': _20231024140000schemanullablechecksum,
 }
 
 
@@ -56,7 +61,6 @@ export class SystemMigrationsRunner {
 	constructor(
 		private readonly databaseContextFactory: DatabaseContextFactory,
 		private readonly project: ProjectConfig & { db: DatabaseConfig },
-		private readonly schema: string,
 		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 		private readonly migrationGroups: Record<string, MigrationGroup<unknown>>,
 		private readonly databaseMetadataResolver: DatabaseMetadataResolver,
@@ -84,7 +88,7 @@ export class SystemMigrationsRunner {
 					]),
 				),
 			)
-			const migrationsRunner = new DbMigrationsRunner(connection, this.schema, migrationResolver)
+			const migrationsRunner = new DbMigrationsRunner(connection, this.project.systemSchema, migrationResolver)
 			await migrationsRunner.migrate(message => logger.warn(message), {
 				project: this.project,
 				schemaResolver,

package/src/migrations/snapshot.ts

@@ -4,6 +4,10 @@ CREATE DOMAIN "event_data_type" AS "text"
 	CONSTRAINT "event_data_type_check" CHECK ((VALUE = ANY (ARRAY['create'::"text", 'update'::"text", 'delete'::"text"])));
 CREATE DOMAIN "event_type" AS "text"
 	CONSTRAINT "event_type_check" CHECK ((VALUE = ANY (ARRAY['init'::"text", 'create'::"text", 'update'::"text", 'delete'::"text", 'run_migration'::"text"])));
+CREATE TYPE "schema_migration_type" AS ENUM (
+    'schema',
+    'content'
+);
 CREATE FUNCTION "trigger_event"() RETURNS "trigger"
     LANGUAGE "plpgsql"
     AS $$
@@ -116,8 +120,9 @@ CREATE TABLE "schema_migration" (
     "version" character varying(20) NOT NULL,
     "name" character varying(255) NOT NULL,
     "migration" "json" NOT NULL,
-    "checksum" character(32) NOT NULL,
-    "executed_at" timestamp with time zone DEFAULT "now"() NOT NULL
+    "checksum" character(32),
+    "executed_at" timestamp with time zone DEFAULT "now"() NOT NULL,
+    "type" "schema_migration_type" DEFAULT 'schema'::"schema_migration_type" NOT NULL
 );
 CREATE SEQUENCE "schema_migration_id_seq"
     AS integer

package/src/model/authorization/AuthorizationActions.ts

@@ -8,4 +8,5 @@ export namespace AuthorizationActions {
 	export const PROJECT_HISTORY_ANY = Authorizator.createAction(Resources.project, 'historyAny')
 
 	export const PROJECT_MIGRATE = Authorizator.createAction(Resources.project, 'migrate')
+	export const PROJECT_LIST_MIGRATIONS = Authorizator.createAction(Resources.project, 'listMigrations')
 }

package/src/model/authorization/PermissionsFactory.ts

@@ -7,6 +7,7 @@ export class PermissionsFactory {
 		const permissions = new Permissions()
 		permissions.allow(ProjectRole.ADMIN, { resource: Permissions.ALL, privilege: Permissions.ALL })
 		permissions.allow(ProjectRole.DEPLOYER, AuthorizationActions.PROJECT_MIGRATE)
+		permissions.allow(ProjectRole.DEPLOYER, AuthorizationActions.PROJECT_LIST_MIGRATIONS)
 
 		return permissions
 	}

package/src/model/commands/migrations/SaveMigrationCommand.ts

@@ -1,20 +1,33 @@
 import { InsertBuilder, QueryBuilder } from '@contember/database'
-import { calculateMigrationChecksum, Migration } from '@contember/schema-migrations'
+import { calculateMigrationChecksum } from '@contember/schema-migrations'
 import { Command } from '../Command'
+import { MigrationInput } from '../../migrations/MigrationInput'
 
-export class SaveMigrationCommand implements Command<void> {
-	constructor(private readonly migration: Migration) {}
+export class SaveMigrationCommand implements Command<number> {
+	constructor(private readonly migration: MigrationInput) {}
+
+	public async execute({ db }: Command.Args): Promise<number> {
+		const { type, ...migrationData } = this.migration
+
+		if ('queries' in migrationData) {
+			// in case of content migration, we don't want to store the queries
+			migrationData.queries = []
+		}
 
-	public async execute({ db }: Command.Args): Promise<void> {
 		const values: QueryBuilder.Values = {
 			version: this.migration.version,
 			name: this.migration.name,
-			migration: JSON.stringify(this.migration),
-			checksum: calculateMigrationChecksum(this.migration),
+			type,
+			migration: JSON.stringify(migrationData),
+			checksum: this.migration.type === 'schema' ? calculateMigrationChecksum(this.migration) : null,
 		}
-		await InsertBuilder.create() //
+
+		const result = await InsertBuilder.create()
 			.into('schema_migration')
 			.values(values)
+			.returning<{id: number}>('id')
 			.execute(db)
+
+		return result[0].id
 	}
 }

package/src/model/dependencies/content/ContentQueryExecutor.ts

@@ -0,0 +1,27 @@
+import { Stage } from '../../dtos'
+import { DatabaseContext } from '../../database'
+import { Schema } from '@contember/schema'
+import { ExecutionResult } from 'graphql'
+import { DatabaseMetadata } from '@contember/database'
+
+export interface ContentQueryExecutorContext {
+	schema: Schema & { id: number }
+	identity: { id: string }
+	db: DatabaseContext
+	stage: Stage
+	project: { slug: string; systemSchema: string }
+	databaseMetadata: DatabaseMetadata
+}
+
+export interface ContentQueryExecutorQuery {
+	query: string
+	variables?: Record<string, any>
+}
+
+export interface ContentQueryExecutor {
+	execute: (ctx: ContentQueryExecutorContext, query: ContentQueryExecutorQuery) => Promise<ContentQueryExecutorResult>
+}
+
+export type ContentQueryExecutorResult =
+	| { ok: false; errors: string[] }
+	| { ok: true; result: ExecutionResult }

package/src/model/dependencies/index.ts

@@ -1 +1,2 @@
 export * from './tenant'
+export * from './content/ContentQueryExecutor'

package/src/model/dtos/ExecutedMigration.ts

@@ -9,7 +9,9 @@ export class ExecutedMigration implements Migration {
 		public readonly formatVersion: number,
 		public readonly modifications: Migration.Modification[],
 		public readonly executedAt: Date,
-		public readonly checksum: string,
+		public readonly checksum: string | null,
+		public readonly type: 'schema' | 'content',
+
 	) {
 		this.version = MigrationVersionHelper.extractVersion(name)
 	}

package/src/model/migrations/MigrationInput.ts

@@ -0,0 +1,25 @@
+import { Migration } from '@contember/schema-migrations'
+
+export type SchemaMigrationInput =
+	& {
+		readonly type: 'schema'
+	}
+	& Migration
+
+export type ContentMigrationInput = {
+	readonly type: 'content'
+	readonly version: string // YYYY-MM-DD-HHIISS
+	readonly name: string // version-label
+	readonly queries: readonly ContentMigrationQuery[]
+}
+
+export type ContentMigrationQuery = {
+	readonly query: string
+	readonly variables?: any
+	readonly stage?: string
+	readonly checkMutationResult?: boolean
+}
+
+export type MigrationInput =
+	| SchemaMigrationInput
+	| ContentMigrationInput

package/src/model/migrations/ProjectMigrator.ts

@@ -1,5 +1,5 @@
 import { calculateMigrationChecksum, Migration, MigrationDescriber, MigrationVersionHelper } from '@contember/schema-migrations'
-import { Client, QueryError, wrapIdentifier } from '@contember/database'
+import { Client, DatabaseMetadata, QueryError, wrapIdentifier } from '@contember/database'
 import { Schema } from '@contember/schema'
 import { SaveMigrationCommand } from '../commands'
 import { Stage } from '../dtos'
@@ -9,10 +9,9 @@ import { MigrateErrorCode } from '../../schema'
 import { SchemaVersionBuilder } from './SchemaVersionBuilder'
 import { SchemaValidator, SchemaValidatorSkippedErrors } from '@contember/schema-utils'
 import { logger } from '@contember/logger'
-import {
-	SchemaDatabaseMetadataResolverStore,
-	MigrationsDatabaseMetadataResolverStoreFactory,
-} from '../metadata/SchemaDatabaseMetadataResolverStore'
+import { MigrationsDatabaseMetadataResolverStoreFactory, SchemaDatabaseMetadataResolverStore } from '../metadata'
+import { ContentMigrationQuery, MigrationInput } from './MigrationInput'
+import { ContentQueryExecutor } from '../dependencies'
 
 export class ProjectMigrator {
 	constructor(
@@ -20,17 +19,20 @@ export class ProjectMigrator {
 		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 		private readonly executedMigrationsResolver: ExecutedMigrationsResolver,
 		private readonly migrationsDatabaseMetadataResolverStoreFactory: MigrationsDatabaseMetadataResolverStoreFactory,
+		private readonly contentQueryExecutor: ContentQueryExecutor,
 	) {}
 
-	public async migrate(
-		db: DatabaseContext,
-		stages: Stage[],
-		migrationsToExecute: readonly Migration[],
-		{ ignoreOrder = false, skipExecuted = false }: {
+	public async migrate({ db, project, identity, options: { ignoreOrder = false, skipExecuted = false }, migrationsToExecute, stages }: {
+		db: DatabaseContext
+		project: { slug: string; systemSchema: string }
+		identity: { id: string }
+		stages: Stage[]
+		migrationsToExecute: readonly MigrationInput[]
+		options: {
 			ignoreOrder?: boolean
 			skipExecuted?: boolean
-		},
-	) {
+		}
+	}) {
 		if (migrationsToExecute.length === 0) {
 			return
 		}
@@ -42,21 +44,73 @@ export class ProjectMigrator {
 		const metadataStore = this.migrationsDatabaseMetadataResolverStoreFactory.create(db)
 
 		for (const migration of sorted) {
-			const formatVersion = migration.formatVersion
-
-			for (const modification of migration.modifications) {
-				[schema] = await this.applyModification(
-					db.client,
-					stages,
-					schema,
-					modification,
-					formatVersion,
-					migration.version,
-					db.client.schema,
-					metadataStore,
-				)
+
+			if (migration.type === 'schema') {
+				const formatVersion = migration.formatVersion
+
+				for (const modification of migration.modifications) {
+					[schema] = await this.applyModification(
+						db.client,
+						stages,
+						schema,
+						modification,
+						formatVersion,
+						migration.version,
+						db.client.schema,
+						metadataStore,
+					)
+				}
+			} else if (migration.type === 'content') {
+				const schemaWithId = {
+					...schema,
+					id,
+				}
+				for (const query of migration.queries) {
+					await this.executeContentMigration({
+						version: migration.version,
+						query,
+						db,
+						schema: schemaWithId,
+						stages,
+						databaseMetadata: await metadataStore.getMetadata(db.client.schema),
+						identity,
+						project,
+					})
+				}
+
+			}
+			id = await db.commandBus.execute(new SaveMigrationCommand(migration))
+		}
+	}
+
+	private async executeContentMigration({ query, stages, version, ...ctx }: {
+		version: string
+		db: DatabaseContext
+		query: ContentMigrationQuery
+		stages: Stage[]
+		schema: Schema & { id: number }
+		project: { slug: string; systemSchema: string }
+		identity: { id: string }
+		databaseMetadata: DatabaseMetadata
+	}) {
+		const queryStages = query.stage ? stages.filter(it => it.slug === query.stage) : stages
+		for (const stage of queryStages) {
+			const response = await this.contentQueryExecutor.execute({
+				stage,
+				...ctx,
+			}, query)
+
+			if (!response.ok) {
+				throw new FailedContentMigrationError(version, response.errors.join(', '))
+			}
+			if (query.checkMutationResult !== false) {
+				for (const [key, value] of Object.entries(response.result.data ?? {})) {
+					if (typeof value === 'object' && value !== null && 'ok' in value && !value.ok) {
+						const errorDetails = 'errorMessage' in value ? value.errorMessage : 'No details available. Please fetch errorMessage field.'
+						throw new NotSuccessfulContentMigrationError(version, `Mutation ${key} failed: ${errorDetails}`)
+					}
+				}
 			}
-			await db.commandBus.execute(new SaveMigrationCommand(migration))
 		}
 	}
 
@@ -64,45 +118,49 @@ export class ProjectMigrator {
 		db: DatabaseContext,
 		schema: Schema,
 		version: string,
-		migrationsToExecute: readonly Migration[],
+		migrationsToExecute: readonly MigrationInput[],
 		{ ignoreOrder, skipExecuted }: {
 			ignoreOrder: boolean
 			skipExecuted: boolean
 		},
-	): Promise<readonly Migration[]> {
+	): Promise<readonly MigrationInput[]> {
 		const executedMigrations = await this.executedMigrationsResolver.getMigrations(db)
-		const toExecute = []
+		const toExecute: MigrationInput[] = []
 		let skippedErrors: SchemaValidatorSkippedErrors[] = []
 		for (const migration of migrationsToExecute) {
 			const executedMigration = executedMigrations.find(it => it.version === migration.version)
 			if (executedMigration) {
-				if (skipExecuted && executedMigration.checksum === calculateMigrationChecksum(migration)) {
+				if (skipExecuted && (migration.type !== 'schema' || executedMigration.checksum === calculateMigrationChecksum(migration))) {
 					continue
 				} else {
 					throw new AlreadyExecutedMigrationError(migration.version, `Migration is already executed`)
 				}
 			}
+
 			if (migration.version < version && !ignoreOrder) {
 				throw new MustFollowLatestMigrationError(migration.version, `Must follow latest executed migration ${version}`)
 			}
-			const described = this.migrationDescriber.describeModifications(schema, migration)
-			if (described.length === 0) {
-				continue
-			}
-			const latestModification = described[described.length - 1]
-			schema = latestModification.schema
-			skippedErrors = [
-				...skippedErrors.filter(it => it.skipUntil && MigrationVersionHelper.extractVersion(it.skipUntil) >= migration.version),
-				...migration.skippedErrors ?? [],
-			]
-			const errors = SchemaValidator.validate(schema, skippedErrors)
-			if (errors.length > 0) {
-				throw new InvalidSchemaError(
-					migration.version,
-					'Migration generates invalid schema: \n' +
-					errors.map(it => `${it.path.join('.')}: [${it.code}] ${it.message}`).join('\n'),
-				)
+			if (migration.type === 'schema') {
+				const described = this.migrationDescriber.describeModifications(schema, migration)
+				if (described.length === 0) {
+					continue
+				}
+				const latestModification = described[described.length - 1]
+				schema = latestModification.schema
+				skippedErrors = [
+					...skippedErrors.filter(it => it.skipUntil && MigrationVersionHelper.extractVersion(it.skipUntil) >= migration.version),
+					...migration.skippedErrors ?? [],
+				]
+				const errors = SchemaValidator.validate(schema, skippedErrors)
+				if (errors.length > 0) {
+					throw new InvalidSchemaError(
+						migration.version,
+						'Migration generates invalid schema: \n' +
+						errors.map(it => `${it.path.join('.')}: [${it.code}] ${it.message}`).join('\n'),
+					)
+				}
 			}
+
 			toExecute.push(migration)
 		}
 		// intentionally not using skippedErrors here
@@ -180,3 +238,11 @@ export class MigrationFailedError extends MigrationError {
 export class InvalidSchemaError extends MigrationError {
 	code = MigrateErrorCode.InvalidSchema
 }
+
+export class FailedContentMigrationError extends MigrationError {
+	code = MigrateErrorCode.ContentMigrationFailed
+}
+
+export class NotSuccessfulContentMigrationError extends MigrationError {
+	code = MigrateErrorCode.ContentMigrationNotSuccessful
+}

package/src/model/migrations/SchemaVersionBuilder.ts

@@ -22,11 +22,16 @@ export class SchemaVersionBuilder {
 		}
 
 		const schema = newMigrations.reduce(
-			(schema, migration) => ({
-				...this.schemaMigrator.applyModifications(schema, migration.modifications, migration.formatVersion),
-				version: migration.version,
-				id: migration.id,
-			}),
+			(schema, migration) => {
+				if (migration.type !== 'schema') {
+					return schema
+				}
+				return ({
+					...this.schemaMigrator.applyModifications(schema, migration.modifications, migration.formatVersion),
+					version: migration.version,
+					id: migration.id,
+				})
+			},
 			after?.notNormalized ?? emptyVersionedSchema.notNormalized,
 		)
 		const normalized = normalizeSchema(schema)

package/src/model/queries/migrations/ExecutedMigrationsQueryHelper.ts

@@ -2,7 +2,7 @@ import { SelectBuilder } from '@contember/database'
 import { ExecutedMigration } from '../../dtos'
 import { VERSION_INITIAL } from '@contember/schema-migrations'
 
-type ExecutedMigrationRow = { id: number; name: string; migration: any; checksum: string; executed_at: Date }
+type ExecutedMigrationRow = { id: number; name: string; migration: any; checksum: string | null; executed_at: Date; type: 'content' | 'schema' }
 export const createExecutedMigrationQueryBuilder = () =>
 	SelectBuilder.create<ExecutedMigrationRow>()
 		.select('id')
@@ -10,6 +10,7 @@ export const createExecutedMigrationQueryBuilder = () =>
 		.select('migration')
 		.select('checksum')
 		.select('executed_at')
+		.select('type')
 		.from('schema_migration')
 		.orderBy('version')
 
@@ -21,4 +22,5 @@ export const createExecutedMigrationDto = (row: ExecutedMigrationRow) =>
 		row.migration.modifications,
 		row.executed_at,
 		row.checksum,
+		row.type,
 	)

package/src/resolvers/SystemResolverContext.ts

@@ -1,7 +1,7 @@
 import { Authorizator } from '@contember/authorization'
 import { Schema } from '@contember/schema'
 import { ForbiddenError } from '@contember/graphql-utils'
-import { DatabaseContext, Identity, SchemaVersionBuilder } from '../model'
+import { DatabaseContext, Identity, VersionedSchema } from '../model'
 import { ProjectConfig } from '../types'
 import { StagePermissionsFactory } from '../model/authorization/StagePermissionsFactory'
 import { StageScope } from '../model/authorization/StageScope'
@@ -13,7 +13,7 @@ export class SystemResolverContextFactory {
 	) {}
 
 	public async create(
-		schema: Schema,
+		schema: VersionedSchema,
 		systemDbContext: DatabaseContext,
 		project: ProjectConfig,
 		identity: Identity,