@contember/engine-system-api 2.0.0-alpha.9 → 2.0.0-beta.2

package/src/model/migrations/ProjectMigrator.ts

@@ -6,17 +6,19 @@ import { Stage } from '../dtos'
 import { DatabaseContext } from '../database'
 import { ExecutedMigrationsResolver } from './ExecutedMigrationsResolver'
 import { MigrateErrorCode } from '../../schema'
-import { SchemaVersionBuilder } from './SchemaVersionBuilder'
-import { SchemaValidator, SchemaValidatorSkippedErrors } from '@contember/schema-utils'
+import { calculateSchemaChecksum, SchemaValidator, SchemaValidatorSkippedErrors } from '@contember/schema-utils'
 import { logger } from '@contember/logger'
 import { MigrationsDatabaseMetadataResolverStoreFactory, SchemaDatabaseMetadataResolverStore } from '../metadata'
 import { ContentMigrationQuery, MigrationInput } from './MigrationInput'
 import { ContentQueryExecutor } from '../dependencies'
+import { SchemaProvider } from './SchemaProvider'
+import { SaveSchemaCommand } from '../commands/schema/SaveSchemaCommand'
+import { ImplementationException } from '../../utils'
 
 export class ProjectMigrator {
 	constructor(
 		private readonly migrationDescriber: MigrationDescriber,
-		private readonly schemaVersionBuilder: SchemaVersionBuilder,
+		private readonly schemaProvider: SchemaProvider,
 		private readonly executedMigrationsResolver: ExecutedMigrationsResolver,
 		private readonly migrationsDatabaseMetadataResolverStoreFactory: MigrationsDatabaseMetadataResolverStoreFactory,
 		private readonly contentQueryExecutor: ContentQueryExecutor,
@@ -36,8 +38,14 @@ export class ProjectMigrator {
 		if (migrationsToExecute.length === 0) {
 			return
 		}
-		let { version, notNormalized, id, ...schema }  = await this.schemaVersionBuilder.buildSchema(db)
-		const validated = await this.validateMigrations(db, schema, version, migrationsToExecute, { ignoreOrder, skipExecuted })
+		const schemaWithMeta = await this.schemaProvider.fetch({ db })
+		let schema = schemaWithMeta.schema
+		let id = schemaWithMeta.meta.id
+
+		const validated = await this.validateMigrations(db, schema, schemaWithMeta.meta.version ?? null, migrationsToExecute, { ignoreOrder, skipExecuted })
+		if (validated.length === 0) {
+			return
+		}
 
 		const sorted = [...validated].sort((a, b) => a.version.localeCompare(b.version))
 
@@ -61,16 +69,16 @@ export class ProjectMigrator {
 					)
 				}
 			} else if (migration.type === 'content') {
-				const schemaWithId = {
-					...schema,
-					id,
+				if (!id) {
+					throw new FailedContentMigrationError(migration.version, `Cannot execute content migration without schema`)
 				}
 				for (const query of migration.queries) {
 					await this.executeContentMigration({
 						version: migration.version,
 						query,
 						db,
-						schema: schemaWithId,
+						schema,
+						schemaMeta: { id },
 						stages,
 						databaseMetadata: await metadataStore.getMetadata(db.client.schema),
 						identity,
@@ -84,6 +92,19 @@ export class ProjectMigrator {
 			}
 			id = await db.commandBus.execute(new SaveMigrationCommand(migration))
 		}
+		if (!id) {
+			throw new ImplementationException()
+		}
+
+		await db.commandBus.execute(new SaveSchemaCommand({
+			schema,
+			meta: {
+				id,
+				updatedAt: new Date(),
+				version: sorted[sorted.length - 1].version,
+				checksum: calculateSchemaChecksum(schema),
+			},
+		}))
 	}
 
 	private async executeContentMigration({ query, stages, version, ...ctx }: {
@@ -91,7 +112,8 @@ export class ProjectMigrator {
 		db: DatabaseContext
 		query: ContentMigrationQuery
 		stages: Stage[]
-		schema: Schema & { id: number }
+		schema: Schema
+		schemaMeta: { id: number }
 		project: { slug: string; systemSchema: string }
 		identity: { id: string }
 		databaseMetadata: DatabaseMetadata
@@ -120,7 +142,7 @@ export class ProjectMigrator {
 	private async validateMigrations(
 		db: DatabaseContext,
 		schema: Schema,
-		version: string,
+		version: string | null,
 		migrationsToExecute: readonly MigrationInput[],
 		{ ignoreOrder, skipExecuted }: {
 			ignoreOrder: boolean
@@ -140,7 +162,7 @@ export class ProjectMigrator {
 				}
 			}
 
-			if (migration.version < version && !ignoreOrder) {
+			if (version && migration.version < version && !ignoreOrder) {
 				throw new MustFollowLatestMigrationError(migration.version, `Must follow latest executed migration ${version}`)
 			}
 			if (migration.type === 'schema') {

package/src/model/migrations/SchemaProvider.ts

@@ -0,0 +1,77 @@
+import { SchemaQuery } from '../queries'
+import { DatabaseContext } from '../database'
+import { calculateSchemaChecksum, emptySchema, normalizeSchema } from '@contember/schema-utils'
+import { ExecutedMigrationsResolver } from './ExecutedMigrationsResolver'
+import { SchemaMigrator } from '@contember/schema-migrations'
+import { Schema } from '@contember/schema'
+
+export type SchemaMeta = {
+	checksum: string
+	version: string
+	updatedAt: Date
+	id: number
+}
+
+export const emptyVersionedSchema: SchemaWithMeta = {
+	schema: emptySchema,
+	meta: {},
+}
+
+export type SchemaWithMeta = {
+	schema: Schema
+	meta: SchemaMeta | { [K in keyof SchemaMeta]?: undefined }
+}
+
+export class SchemaProvider {
+	constructor(
+		private readonly executedMigrationsResolver: ExecutedMigrationsResolver,
+		private readonly schemaMigrator: SchemaMigrator,
+	) {
+	}
+
+	async buildSchemaFromMigrations(db: DatabaseContext): Promise<SchemaWithMeta> {
+		const newMigrations = (await this.executedMigrationsResolver.getMigrations(db))
+
+		const partialResult = newMigrations.reduce<SchemaWithMeta>(
+			(schema, migration) => {
+				if (migration.type !== 'schema') {
+					return schema
+				}
+				return {
+					schema: this.schemaMigrator.applyModifications(schema.schema, migration.modifications, migration.formatVersion),
+					meta: {
+						version: migration.version,
+						id: migration.id,
+						updatedAt: migration.executedAt,
+						checksum: '',
+					},
+				}
+			},
+			emptyVersionedSchema,
+		)
+
+		if (!partialResult.meta.version) {
+			return emptyVersionedSchema
+		}
+
+		return {
+			schema: partialResult.schema,
+			meta: {
+				...partialResult.meta,
+				checksum: calculateSchemaChecksum(partialResult.schema),
+			},
+		}
+	}
+
+	public async fetch({ db, currentSchema  }: {
+		db: DatabaseContext
+		currentSchema?: SchemaWithMeta | null
+	}): Promise<SchemaWithMeta> {
+		const newSchema = await db.queryHandler.fetch(new SchemaQuery(currentSchema?.meta.checksum))
+		if (!newSchema) {
+			return currentSchema ?? emptyVersionedSchema
+		}
+
+		return newSchema
+	}
+}

package/src/model/migrations/index.ts

@@ -1,4 +1,4 @@
 export * from './ExecutedMigrationsResolver'
 export * from './MigrationAlterer'
 export * from './ProjectMigrator'
-export * from './SchemaVersionBuilder'
+export * from './SchemaProvider'

package/src/model/queries/events/EventsQuery.ts

@@ -2,6 +2,7 @@ import {
 	ConditionBuilder,
 	DatabaseQuery,
 	DatabaseQueryable,
+	Literal,
 	Operator,
 	SelectBuilder,
 	SelectBuilderSpecification, Value,
@@ -78,23 +79,20 @@ export class EventsQuery extends DatabaseQuery<ContentEvent[]> {
 				if (!this.filter.rows) {
 					return qb
 				}
-				type PrimaryKey = readonly string[]
-				const byTable: Record<string, PrimaryKey[]> = {}
-				for (const row of this.filter.rows) {
-					byTable[row.tableName] ??= []
-					byTable[row.tableName].push(row.primaryKey)
-				}
-				const rowFilters = Object.entries(byTable)
-				const ors = rowFilters.reduce(
-					(expr, [table, rowIds]) =>
-						expr.and(
-							ConditionBuilder.create()
-								.compare('table_name', Operator.eq, table)
-								.in('row_ids', rowIds.map(it => JSON.stringify(it))),
-						),
-					ConditionBuilder.create(),
-				)
-				return qb.where(ConditionBuilder.create().or(ors))
+
+				const ors: Literal[] = this.filter.rows.map(row => {
+					const builder = ConditionBuilder.create()
+						.compare('table_name', Operator.eq, row.tableName)
+
+					return row.primaryKey.reduce((expr, val, index) => {
+						if (val === null) {
+							return expr
+						}
+						return expr.raw(`"row_ids"->${index} = ?::jsonb`, JSON.stringify(val))
+					}, builder).getSql()
+				}).filter((it): it is Literal => it !== null)
+
+				return qb.where(ConditionBuilder.create().or(ConditionBuilder.create(ors)))
 			})
 
 			.limit(this.limit, this.offset)

package/src/model/queries/index.ts

@@ -1,3 +1,4 @@
 export * from './migrations'
 export * from './events'
 export * from './stages'
+export * from './schema'

package/src/model/queries/schema/SchemaQuery.ts

@@ -0,0 +1,48 @@
+import { DatabaseQuery, DatabaseQueryable, Literal, SelectBuilder } from '@contember/database'
+import { Schema } from '@contember/schema'
+import { SchemaWithMeta } from '../../migrations'
+
+export class SchemaQuery extends DatabaseQuery<SchemaWithMeta | null> {
+
+	constructor(
+		private readonly currentHash?: string,
+	) {
+		super()
+	}
+
+
+	async fetch(queryable: DatabaseQueryable): Promise<SchemaWithMeta | null> {
+		const query = SelectBuilder.create<{
+			schema: Schema
+			checksum: string
+			version: string
+			updated_at: Date
+			migration_id: number
+		}>()
+			.from('schema')
+			.select(new Literal('*'))
+			.where({
+				id: 'single',
+			})
+			.match(it => {
+				if (!this.currentHash) {
+					return it
+				}
+				return it.where(it => it.raw('checksum != ?', this.currentHash))
+			})
+
+		const row =  this.fetchOneOrNull(await query.getResult(queryable.db))
+		if (!row) {
+			return null
+		}
+		return {
+			schema: row.schema,
+			meta: {
+				checksum: row.checksum,
+				version: row.version,
+				updatedAt: row.updated_at,
+				id: row.migration_id,
+			},
+		}
+	}
+}

package/src/model/queries/schema/index.ts

@@ -0,0 +1 @@
+export * from './SchemaQuery'

package/src/resolvers/ResolverFactory.ts

@@ -2,9 +2,10 @@ import { EventsQueryResolver, ExecutedMigrationsQueryResolver, StagesQueryResolv
 import { Event, EventType, Resolvers } from '../schema'
 import { assertNever } from '../utils'
 import { MigrateMutationResolver, MigrationAlterMutationResolver, TruncateMutationResolver } from './mutation'
-import { DateTimeType, JSONType } from '@contember/graphql-utils'
+import { DateTimeType, JSONType, createJsonLikeType } from '@contember/graphql-utils'
 import { EventOldValuesResolver } from './types'
 import { GraphQLError, GraphQLScalarType, Kind } from 'graphql'
+import { SchemaQueryResolver } from './query/SchemaQueryResolver'
 
 export class ResolverFactory {
 	public constructor(
@@ -15,6 +16,7 @@ export class ResolverFactory {
 		private readonly migrationAlterMutationResolver: MigrationAlterMutationResolver,
 		private readonly eventsQueryResolver: EventsQueryResolver,
 		private readonly eventOldValuesResolver: EventOldValuesResolver,
+		private readonly schemaQueryResolver: SchemaQueryResolver,
 	) {}
 
 	create(debugMode: boolean): Resolvers {
@@ -22,6 +24,7 @@ export class ResolverFactory {
 			DateTime: DateTimeType,
 			Json: JSONType,
 			PrimaryKey: PrimaryKeyType,
+			Schema: SchemaType,
 			Event: {
 				__resolveType: (obj: Event) => {
 					switch (obj.type) {
@@ -43,6 +46,7 @@ export class ResolverFactory {
 				stages: this.stagesQueryResolver.stages.bind(this.stagesQueryResolver),
 				executedMigrations: this.executedMigrationsQueryResolver.executedMigrations.bind(this.executedMigrationsQueryResolver),
 				events: this.eventsQueryResolver.events.bind(this.eventsQueryResolver),
+				schema: this.schemaQueryResolver.schema.bind(this.schemaQueryResolver),
 			},
 			Mutation: {
 				migrate: this.migrateMutationResolver.migrate.bind(this.migrateMutationResolver),
@@ -70,6 +74,10 @@ const parseValue = (value: any)  => {
 	}
 	throw new GraphQLError('PrimaryKey cannot represent value: ' + JSON.stringify(value))
 }
+
+const SchemaType = createJsonLikeType('Schema', 'Content schema custom scalar type')
+
+
 export const PrimaryKeyType = new GraphQLScalarType({
 	name: 'PrimaryKey',
 	description: 'PrimaryKey custom scalar type. Can be Int or String',

package/src/resolvers/SystemResolverContext.ts

@@ -1,31 +1,26 @@
 import { Authorizator } from '@contember/authorization'
-import { Schema } from '@contember/schema'
 import { ForbiddenError } from '@contember/graphql-utils'
-import { DatabaseContext, Identity, VersionedSchema } from '../model'
+import { DatabaseContext, Identity } from '../model'
 import { ProjectConfig } from '../types'
 import { StagePermissionsFactory } from '../model/authorization/StagePermissionsFactory'
 import { StageScope } from '../model/authorization/StageScope'
 import { ItemLoader } from '../utils/batchQuery'
+import { SchemaGetter } from '../model/SchemaGetter'
 
 export class SystemResolverContextFactory {
 	constructor(
 		private readonly authorizator: Authorizator<Identity>,
 	) {}
 
-	public async create(
-		schema: VersionedSchema,
-		systemDbContext: DatabaseContext,
-		project: ProjectConfig,
-		identity: Identity,
-	): Promise<SystemResolverContext> {
-		const stagePermissionsFactory = new StagePermissionsFactory(schema)
+	public async create({ getSchema, identity, project, db }: Pick<SystemResolverContext, 'getSchema' | 'db' | 'identity' | 'project'>): Promise<SystemResolverContext> {
+		const stagePermissionsFactory = new StagePermissionsFactory(getSchema)
 		const loaders = new Map<LoaderFactory<any, any>, ItemLoader<any, any>>()
 		return {
 			project,
 			identity,
-			schema,
+			getSchema,
 			authorizator: this.authorizator,
-			db: systemDbContext,
+			db,
 			requireAccess: async (action, stage, message?) => {
 				if (!(await this.authorizator.isAllowed(identity, new StageScope(stage, stagePermissionsFactory), action))) {
 					throw new ForbiddenError(message || 'Forbidden')
@@ -36,7 +31,7 @@ export class SystemResolverContextFactory {
 				if (loader) {
 					return loader
 				}
-				const newLoader = loaderFactory(systemDbContext)
+				const newLoader = loaderFactory(db)
 				loaders.set(loaderFactory, newLoader)
 				return newLoader
 			},
@@ -48,7 +43,7 @@ export type LoaderFactory<Args, Item> = (db: DatabaseContext) => ItemLoader<Args
 
 export interface SystemResolverContext {
 	readonly project: ProjectConfig
-	readonly schema: Schema
+	readonly getSchema: SchemaGetter
 	readonly identity: Identity
 	readonly db: DatabaseContext
 	readonly authorizator: Authorizator<Identity>

package/src/resolvers/mutation/TruncateMutationResolver.ts

@@ -12,7 +12,7 @@ export class TruncateMutationResolver implements MutationResolver<'truncate'> {
 		context: SystemResolverContext,
 		info: GraphQLResolveInfo,
 	): Promise<TruncateResponse> {
-		await this.projectTruncateExecutor.truncateProject(context.db, context.project, context.schema)
+		await this.projectTruncateExecutor.truncateProject(context.db, context.project, await context.getSchema())
 		return {
 			ok: true,
 		}

package/src/resolvers/query/SchemaQueryResolver.ts

@@ -0,0 +1,19 @@
+import { GraphQLResolveInfo } from 'graphql'
+import { SystemResolverContext } from '../SystemResolverContext'
+import { QueryResolver } from '../Resolver'
+import { AuthorizationActions, StagesQuery } from '../../model'
+
+export class SchemaQueryResolver implements QueryResolver<'schema'> {
+	async schema(
+		parent: any,
+		args: unknown,
+		context: SystemResolverContext,
+		info: GraphQLResolveInfo,
+	) {
+		const stages = await context.db.queryHandler.fetch(new StagesQuery())
+		for (const stage of stages) {
+			await context.requireAccess(AuthorizationActions.PROJECT_SHOW_SCHEMA, stage.slug)
+		}
+		return context.getSchema()
+	}
+}

package/src/schema/system.graphql.ts

@@ -5,6 +5,7 @@ const schema: DocumentNode = gql`
 	scalar DateTime
 	scalar Json
 	scalar PrimaryKey
+	scalar Schema
 
 	schema {
 		query: Query
@@ -15,6 +16,7 @@ const schema: DocumentNode = gql`
 		stages: [Stage!]!
 		executedMigrations(version: String): [ExecutedMigration!]!
 		events(args: EventsArgs): [Event!]!
+		schema: Schema!
 	}
 
 	type Mutation {
@@ -56,7 +58,7 @@ const schema: DocumentNode = gql`
 
 	input EventFilterRow {
 		tableName: String!
-		primaryKey: [PrimaryKey!]!
+		primaryKey: [PrimaryKey]!
 	}
 
 	interface Event {

package/src/schema/types.ts

@@ -16,7 +16,8 @@ export type Scalars = {
 	Float: { input: number; output: number }
 	DateTime: { input: Date; output: Date }
 	Json: { input: unknown; output: unknown }
-	PrimaryKey: { input: any; output: any }
+	PrimaryKey: { input: string | number; output: string | number }
+	Schema: { input: any; output: any }
 }
 
 export type ContentMigration = {
@@ -70,7 +71,7 @@ export type Event = {
 }
 
 export type EventFilterRow = {
-	readonly primaryKey: ReadonlyArray<Scalars['PrimaryKey']['input']>
+	readonly primaryKey: ReadonlyArray<InputMaybe<Scalars['PrimaryKey']['input']>>
 	readonly tableName: Scalars['String']['input']
 }
 
@@ -250,6 +251,7 @@ export type Query = {
 	readonly __typename?: 'Query'
 	readonly events: ReadonlyArray<Event>
 	readonly executedMigrations: ReadonlyArray<ExecutedMigration>
+	readonly schema: Scalars['Schema']['output']
 	readonly stages: ReadonlyArray<Stage>
 }
 
@@ -366,7 +368,7 @@ export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs
 
 
 /** Mapping of interface types */
-export type ResolversInterfaceTypes<RefType extends Record<string, unknown>> = {
+export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> = {
 	Event: (CreateEvent) | (DeleteEvent) | (UpdateEvent)
 }
 
@@ -404,6 +406,7 @@ export type ResolversTypes = {
 	Mutation: ResolverTypeWrapper<{}>
 	PrimaryKey: ResolverTypeWrapper<Scalars['PrimaryKey']['output']>
 	Query: ResolverTypeWrapper<{}>
+	Schema: ResolverTypeWrapper<Scalars['Schema']['output']>
 	SchemaMigration: SchemaMigration
 	Stage: ResolverTypeWrapper<Stage>
 	String: ResolverTypeWrapper<Scalars['String']['output']>
@@ -439,6 +442,7 @@ export type ResolversParentTypes = {
 	Mutation: {}
 	PrimaryKey: Scalars['PrimaryKey']['output']
 	Query: {}
+	Schema: Scalars['Schema']['output']
 	SchemaMigration: SchemaMigration
 	Stage: Stage
 	String: Scalars['String']['output']
@@ -567,9 +571,14 @@ export interface PrimaryKeyScalarConfig extends GraphQLScalarTypeConfig<Resolver
 export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
 	events?: Resolver<ReadonlyArray<ResolversTypes['Event']>, ParentType, ContextType, Partial<QueryEventsArgs>>
 	executedMigrations?: Resolver<ReadonlyArray<ResolversTypes['ExecutedMigration']>, ParentType, ContextType, Partial<QueryExecutedMigrationsArgs>>
+	schema?: Resolver<ResolversTypes['Schema'], ParentType, ContextType>
 	stages?: Resolver<ReadonlyArray<ResolversTypes['Stage']>, ParentType, ContextType>
 }
 
+export interface SchemaScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Schema'], any> {
+	name: 'Schema'
+}
+
 export type StageResolvers<ContextType = any, ParentType extends ResolversParentTypes['Stage'] = ResolversParentTypes['Stage']> = {
 	id?: Resolver<ResolversTypes['String'], ParentType, ContextType>
 	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
@@ -615,6 +624,7 @@ export type Resolvers<ContextType = any> = {
 	Mutation?: MutationResolvers<ContextType>
 	PrimaryKey?: GraphQLScalarType
 	Query?: QueryResolvers<ContextType>
+	Schema?: GraphQLScalarType
 	Stage?: StageResolvers<ContextType>
 	TruncateResponse?: TruncateResponseResolvers<ContextType>
 	UpdateEvent?: UpdateEventResolvers<ContextType>

package/tests/cases/migrations/2020-05-06-150000-composed-primary.test.ts

@@ -1,7 +1,7 @@
 import { emptyDatabaseMetadata } from '@contember/database'
 import migration from '../../../src/migrations/2020-05-06-150000-composed-primary'
 import { createMigrationBuilder } from '@contember/database-migrations'
-import { assert, test } from 'vitest'
+import { expect, test } from 'bun:test'
 import { c, createSchema } from '@contember/schema-definition'
 
 namespace SampleProject {
@@ -37,7 +37,15 @@ test('many-has-many-primary migration sql', async () => {
 	const builder = createMigrationBuilder()
 	await migration(builder, {
 		connection: undefined as any,
-		schemaResolver: () => Promise.resolve(createSchema(SampleProject)),
+		schemaResolver: () => Promise.resolve({
+			schema: createSchema(SampleProject),
+			meta: {
+				id: 1,
+				version: '2024-06-28-153001',
+				checksum: '_checksum_',
+				updatedAt: new Date(),
+			},
+		}),
 		databaseMetadataResolver: () => Promise.resolve(emptyDatabaseMetadata),
 		project: {
 			slug: 'test',
@@ -54,8 +62,9 @@ test('many-has-many-primary migration sql', async () => {
 			],
 		},
 	})
-	assert.equal(
+	expect(
 		builder.getSql(),
+	).toEqual(
 		`ALTER TABLE "stage_prod"."post_tags"
   DROP "id";
 ALTER TABLE "stage_prod"."post_tags" DROP CONSTRAINT "post_tags_uniq_post_id_tag_id";

package/tests/cases/migrations/2020-06-01-103000-event-trigger-perf.test.ts

@@ -1,6 +1,6 @@
 import migration from '../../../src/migrations/2020-06-01-103000-event-trigger-perf'
 import { createMigrationBuilder } from '@contember/database-migrations'
-import { assert, test } from 'vitest'
+import { expect, test } from 'bun:test'
 import { emptyDatabaseMetadata } from '@contember/database'
 import { c, createSchema } from '@contember/schema-definition'
 
@@ -37,7 +37,15 @@ test('event-trigger-performance sql', async () => {
 	const builder = createMigrationBuilder()
 	await migration(builder, {
 		connection: undefined as any,
-		schemaResolver: () => Promise.resolve(createSchema(SampleProject)),
+		schemaResolver: () => Promise.resolve({
+			schema: createSchema(SampleProject),
+			meta: {
+				id: 1,
+				version: '2024-06-28-153001',
+				checksum: '_checksum_',
+				updatedAt: new Date(),
+			},
+		}),
 		databaseMetadataResolver: () => Promise.resolve(emptyDatabaseMetadata),
 		project: {
 			slug: 'test',
@@ -54,8 +62,9 @@ test('event-trigger-performance sql', async () => {
 			],
 		},
 	})
-	assert.equal(
+	expect(
 		builder.getSql(),
+	).toEqual(
 		`CREATE OR REPLACE FUNCTION "trigger_event"() RETURNS TRIGGER AS $$
 DECLARE
     DECLARE new_event_type TEXT;

package/tests/cases/migrations/2022-10-03-110000-table-on-delete.test.ts

@@ -1,6 +1,6 @@
 import migration from '../../../src/migrations/2022-10-03-110000-table-on-delete'
 import { createMigrationBuilder } from '@contember/database-migrations'
-import { assert, test } from 'vitest'
+import { expect, test } from 'bun:test'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { emptySchema } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
@@ -30,12 +30,23 @@ test('table-on-delete test', async () => {
 				deferred: false,
 			}],
 		})),
-		schemaResolver: () => Promise.resolve(({ ...emptySchema, model: new SchemaBuilder()
-			.entity('Post', entity =>
-				entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
-			)
-			.entity('Author', entity => entity)
-			.buildSchema() })),
+		schemaResolver: () => Promise.resolve(({
+			schema: {
+				...emptySchema,
+				model: new SchemaBuilder()
+					.entity('Post', entity =>
+						entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
+					)
+					.entity('Author', entity => entity)
+					.buildSchema(),
+			},
+			meta: {
+				id: 1,
+				version: '2024-06-28-153001',
+				checksum: '_checksum_',
+				updatedAt: new Date(),
+			},
+		})),
 		project: {
 			slug: 'test',
 			systemSchema: 'system',
@@ -47,8 +58,9 @@ test('table-on-delete test', async () => {
 			],
 		},
 	})
-	assert.equal(
+	expect(
 		builder.getSql(),
+	).toEqual(
 		`ALTER TABLE "stage_live"."post" DROP CONSTRAINT "fk_post_author_id_author_id";
 ALTER TABLE "stage_live"."post"
 					ADD FOREIGN KEY ("author_id")