@contember/engine-system-api 2.1.0-alpha.30 → 2.1.0-alpha.36

package/src/schema/types.ts

@@ -78,7 +78,7 @@ export type EventFilterRow = {
 export enum EventType {
 	Create = 'CREATE',
 	Delete = 'DELETE',
-	Update = 'UPDATE'
+	Update = 'UPDATE',
 }
 
 export type EventsArgs = {
@@ -109,7 +109,7 @@ export enum EventsOrder {
 	AppliedAtAsc = 'APPLIED_AT_ASC',
 	AppliedAtDesc = 'APPLIED_AT_DESC',
 	CreatedAtAsc = 'CREATED_AT_ASC',
-	CreatedAtDesc = 'CREATED_AT_DESC'
+	CreatedAtDesc = 'CREATED_AT_DESC',
 }
 
 export type ExecutedMigration = {
@@ -136,7 +136,7 @@ export enum MigrateErrorCode {
 	InvalidFormat = 'INVALID_FORMAT',
 	InvalidSchema = 'INVALID_SCHEMA',
 	MigrationFailed = 'MIGRATION_FAILED',
-	MustFollowLatest = 'MUST_FOLLOW_LATEST'
+	MustFollowLatest = 'MUST_FOLLOW_LATEST',
 }
 
 export type MigrateResponse = {
@@ -175,7 +175,7 @@ export type MigrationDeleteError = {
 
 export enum MigrationDeleteErrorCode {
 	InvalidFormat = 'INVALID_FORMAT',
-	NotFound = 'NOT_FOUND'
+	NotFound = 'NOT_FOUND',
 }
 
 export type MigrationDeleteResponse = {
@@ -198,7 +198,7 @@ export type MigrationModifyError = {
 }
 
 export enum MigrationModifyErrorCode {
-	NotFound = 'NOT_FOUND'
+	NotFound = 'NOT_FOUND',
 }
 
 export type MigrationModifyResponse = {
@@ -214,7 +214,7 @@ export type MigrationSkippedError = {
 
 export enum MigrationType {
 	Content = 'CONTENT',
-	Schema = 'SCHEMA'
+	Schema = 'SCHEMA',
 }
 
 export type Mutation = {
@@ -226,22 +226,18 @@ export type Mutation = {
 	readonly truncate: TruncateResponse
 }
 
-
 export type MutationForceMigrateArgs = {
 	migrations: ReadonlyArray<Migration>
 }
 
-
 export type MutationMigrateArgs = {
 	migrations: ReadonlyArray<Migration>
 }
 
-
 export type MutationMigrationDeleteArgs = {
 	migration: Scalars['String']['input']
 }
 
-
 export type MutationMigrationModifyArgs = {
 	migration: Scalars['String']['input']
 	modification: MigrationModification
@@ -255,12 +251,10 @@ export type Query = {
 	readonly stages: ReadonlyArray<Stage>
 }
 
-
 export type QueryEventsArgs = {
 	args?: InputMaybe<EventsArgs>
 }
 
-
 export type QueryExecutedMigrationsArgs = {
 	version?: InputMaybe<Scalars['String']['input']>
 }
@@ -299,35 +293,34 @@ export type UpdateEvent = Event & {
 	readonly type: EventType
 }
 
-
-
 export type ResolverTypeWrapper<T> = Promise<T> | T
 
-
 export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
 	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
 }
-export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
+	| ResolverFn<TResult, TParent, TContext, TArgs>
+	| ResolverWithResolve<TResult, TParent, TContext, TArgs>
 
 export type ResolverFn<TResult, TParent, TContext, TArgs> = (
 	parent: TParent,
 	args: TArgs,
 	context: TContext,
-	info: GraphQLResolveInfo
+	info: GraphQLResolveInfo,
 ) => Promise<TResult> | TResult
 
 export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
 	parent: TParent,
 	args: TArgs,
 	context: TContext,
-	info: GraphQLResolveInfo
+	info: GraphQLResolveInfo,
 ) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
 
 export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
 	parent: TParent,
 	args: TArgs,
 	context: TContext,
-	info: GraphQLResolveInfo
+	info: GraphQLResolveInfo,
 ) => TResult | Promise<TResult>
 
 export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
@@ -341,17 +334,17 @@ export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
 }
 
 export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
-  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
-  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>
+	| SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
+	| SubscriptionResolverObject<TResult, TParent, TContext, TArgs>
 
 export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
-  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
-  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>
+	| ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
+	| SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>
 
 export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
 	parent: TParent,
 	context: TContext,
-	info: GraphQLResolveInfo
+	info: GraphQLResolveInfo,
 ) => Maybe<TTypes> | Promise<Maybe<TTypes>>
 
 export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>
@@ -363,10 +356,9 @@ export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs
 	parent: TParent,
 	args: TArgs,
 	context: TContext,
-	info: GraphQLResolveInfo
+	info: GraphQLResolveInfo,
 ) => TResult | Promise<TResult>
 
-
 /** Mapping of interface types */
 export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> = {
 	Event: (CreateEvent) | (DeleteEvent) | (UpdateEvent)
@@ -498,7 +490,10 @@ export type EventResolvers<ContextType = any, ParentType extends ResolversParent
 	type?: Resolver<ResolversTypes['EventType'], ParentType, ContextType>
 }
 
-export type ExecutedMigrationResolvers<ContextType = any, ParentType extends ResolversParentTypes['ExecutedMigration'] = ResolversParentTypes['ExecutedMigration']> = {
+export type ExecutedMigrationResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['ExecutedMigration'] = ResolversParentTypes['ExecutedMigration'],
+> = {
 	checksum?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
 	executedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
 	formatVersion?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>
@@ -512,14 +507,18 @@ export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes
 	name: 'Json'
 }
 
-export type MigrateErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['MigrateError'] = ResolversParentTypes['MigrateError']> = {
-	code?: Resolver<ResolversTypes['MigrateErrorCode'], ParentType, ContextType>
-	developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	migration?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
+export type MigrateErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['MigrateError'] = ResolversParentTypes['MigrateError']> =
+	{
+		code?: Resolver<ResolversTypes['MigrateErrorCode'], ParentType, ContextType>
+		developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+		migration?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+		__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
+	}
 
-export type MigrateResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['MigrateResponse'] = ResolversParentTypes['MigrateResponse']> = {
+export type MigrateResponseResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['MigrateResponse'] = ResolversParentTypes['MigrateResponse'],
+> = {
 	error?: Resolver<Maybe<ResolversTypes['MigrateError']>, ParentType, ContextType>
 	errors?: Resolver<ReadonlyArray<ResolversTypes['MigrateError']>, ParentType, ContextType>
 	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
@@ -527,30 +526,45 @@ export type MigrateResponseResolvers<ContextType = any, ParentType extends Resol
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
-export type MigrateResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['MigrateResult'] = ResolversParentTypes['MigrateResult']> = {
+export type MigrateResultResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['MigrateResult'] = ResolversParentTypes['MigrateResult'],
+> = {
 	message?: Resolver<ResolversTypes['String'], ParentType, ContextType>
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
-export type MigrationDeleteErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['MigrationDeleteError'] = ResolversParentTypes['MigrationDeleteError']> = {
+export type MigrationDeleteErrorResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['MigrationDeleteError'] = ResolversParentTypes['MigrationDeleteError'],
+> = {
 	code?: Resolver<ResolversTypes['MigrationDeleteErrorCode'], ParentType, ContextType>
 	developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
-export type MigrationDeleteResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['MigrationDeleteResponse'] = ResolversParentTypes['MigrationDeleteResponse']> = {
+export type MigrationDeleteResponseResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['MigrationDeleteResponse'] = ResolversParentTypes['MigrationDeleteResponse'],
+> = {
 	error?: Resolver<Maybe<ResolversTypes['MigrationDeleteError']>, ParentType, ContextType>
 	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
-export type MigrationModifyErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['MigrationModifyError'] = ResolversParentTypes['MigrationModifyError']> = {
+export type MigrationModifyErrorResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['MigrationModifyError'] = ResolversParentTypes['MigrationModifyError'],
+> = {
 	code?: Resolver<ResolversTypes['MigrationModifyErrorCode'], ParentType, ContextType>
 	developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
-export type MigrationModifyResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['MigrationModifyResponse'] = ResolversParentTypes['MigrationModifyResponse']> = {
+export type MigrationModifyResponseResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['MigrationModifyResponse'] = ResolversParentTypes['MigrationModifyResponse'],
+> = {
 	error?: Resolver<Maybe<ResolversTypes['MigrationModifyError']>, ParentType, ContextType>
 	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
@@ -559,8 +573,18 @@ export type MigrationModifyResponseResolvers<ContextType = any, ParentType exten
 export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
 	forceMigrate?: Resolver<ResolversTypes['MigrateResponse'], ParentType, ContextType, RequireFields<MutationForceMigrateArgs, 'migrations'>>
 	migrate?: Resolver<ResolversTypes['MigrateResponse'], ParentType, ContextType, RequireFields<MutationMigrateArgs, 'migrations'>>
-	migrationDelete?: Resolver<ResolversTypes['MigrationDeleteResponse'], ParentType, ContextType, RequireFields<MutationMigrationDeleteArgs, 'migration'>>
-	migrationModify?: Resolver<ResolversTypes['MigrationModifyResponse'], ParentType, ContextType, RequireFields<MutationMigrationModifyArgs, 'migration' | 'modification'>>
+	migrationDelete?: Resolver<
+		ResolversTypes['MigrationDeleteResponse'],
+		ParentType,
+		ContextType,
+		RequireFields<MutationMigrationDeleteArgs, 'migration'>
+	>
+	migrationModify?: Resolver<
+		ResolversTypes['MigrationModifyResponse'],
+		ParentType,
+		ContextType,
+		RequireFields<MutationMigrationModifyArgs, 'migration' | 'modification'>
+	>
 	truncate?: Resolver<ResolversTypes['TruncateResponse'], ParentType, ContextType>
 }
 
@@ -586,7 +610,10 @@ export type StageResolvers<ContextType = any, ParentType extends ResolversParent
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
-export type TruncateResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['TruncateResponse'] = ResolversParentTypes['TruncateResponse']> = {
+export type TruncateResponseResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['TruncateResponse'] = ResolversParentTypes['TruncateResponse'],
+> = {
 	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
@@ -629,4 +656,3 @@ export type Resolvers<ContextType = any> = {
 	TruncateResponse?: TruncateResponseResolvers<ContextType>
 	UpdateEvent?: UpdateEventResolvers<ContextType>
 }
-

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

@@ -37,15 +37,16 @@ test('many-has-many-primary migration sql', async () => {
 	const builder = createMigrationBuilder()
 	await migration(builder, {
 		connection: undefined as any,
-		schemaResolver: () => Promise.resolve({
-			schema: createSchema(SampleProject),
-			meta: {
-				id: 1,
-				version: '2024-06-28-153001',
-				checksum: '_checksum_',
-				updatedAt: new Date(),
-			},
-		}),
+		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',

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

@@ -37,15 +37,16 @@ test('event-trigger-performance sql', async () => {
 	const builder = createMigrationBuilder()
 	await migration(builder, {
 		connection: undefined as any,
-		schemaResolver: () => Promise.resolve({
-			schema: createSchema(SampleProject),
-			meta: {
-				id: 1,
-				version: '2024-06-28-153001',
-				checksum: '_checksum_',
-				updatedAt: new Date(),
-			},
-		}),
+		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',
@@ -205,4 +206,3 @@ CREATE TRIGGER "log_event_statement"
 `,
 	)
 })
-

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

@@ -5,8 +5,7 @@ import { SchemaBuilder } from '@contember/schema-definition'
 import { emptySchema } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
 import { createConnectionMock } from '@contember/database-tester'
-import { ForeignKeyDeleteAction, createDatabaseMetadata, emptyDatabaseMetadata } from '@contember/database'
-
+import { createDatabaseMetadata, emptyDatabaseMetadata, ForeignKeyDeleteAction } from '@contember/database'
 
 test('table-on-delete test', async () => {
 	const builder = createMigrationBuilder()
@@ -16,37 +15,37 @@ test('table-on-delete test', async () => {
 	}])
 	await migration(builder, {
 		connection: connection,
-		databaseMetadataResolver: () => Promise.resolve(createDatabaseMetadata({
-			indexes: [],
-			uniqueConstraints: [],
-			foreignKeys: [{
-				constraintName: 'fk_post_author_id_author_id',
-				fromColumn: 'author_id',
-				fromTable: 'post',
-				toColumn: 'id',
-				toTable: 'author',
-				deleteAction: ForeignKeyDeleteAction.restrict,
-				deferrable: false,
-				deferred: false,
-			}],
-		})),
-		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(),
-			},
-		})),
+		databaseMetadataResolver: () =>
+			Promise.resolve(createDatabaseMetadata({
+				indexes: [],
+				uniqueConstraints: [],
+				foreignKeys: [{
+					constraintName: 'fk_post_author_id_author_id',
+					fromColumn: 'author_id',
+					fromTable: 'post',
+					toColumn: 'id',
+					toTable: 'author',
+					deleteAction: ForeignKeyDeleteAction.restrict,
+					deferrable: false,
+					deferred: false,
+				}],
+			})),
+		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',
@@ -69,4 +68,3 @@ ALTER TABLE "stage_live"."post"
 `,
 	)
 })
-

package/tests/cases/migrations/2023-09-11-174000-fix-on-delete.test.ts

@@ -5,8 +5,7 @@ import { SchemaBuilder } from '@contember/schema-definition'
 import { emptySchema } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
 import { createConnectionMock } from '@contember/database-tester'
-import { ForeignKeyDeleteAction, createDatabaseMetadata, emptyDatabaseMetadata } from '@contember/database'
-
+import { createDatabaseMetadata, emptyDatabaseMetadata, ForeignKeyDeleteAction } from '@contember/database'
 
 test('table-on-delete test', async () => {
 	const builder = createMigrationBuilder()
@@ -16,37 +15,37 @@ test('table-on-delete test', async () => {
 	}])
 	await migration(builder, {
 		connection: connection,
-		databaseMetadataResolver: () => Promise.resolve(createDatabaseMetadata({
-			indexes: [],
-			uniqueConstraints: [],
-			foreignKeys: [{
-				constraintName: 'fk_post_author_id_author_id',
-				fromColumn: 'author_id',
-				fromTable: 'post',
-				toColumn: 'id',
-				toTable: 'author',
-				deleteAction: ForeignKeyDeleteAction.cascade,
-				deferrable: false,
-				deferred: false,
-			}],
-		})),
-		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(),
-			},
-		})),
+		databaseMetadataResolver: () =>
+			Promise.resolve(createDatabaseMetadata({
+				indexes: [],
+				uniqueConstraints: [],
+				foreignKeys: [{
+					constraintName: 'fk_post_author_id_author_id',
+					fromColumn: 'author_id',
+					fromTable: 'post',
+					toColumn: 'id',
+					toTable: 'author',
+					deleteAction: ForeignKeyDeleteAction.cascade,
+					deferrable: false,
+					deferred: false,
+				}],
+			})),
+		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',
@@ -59,7 +58,8 @@ test('table-on-delete test', async () => {
 		},
 	})
 	expect(
-		builder.getSql()).toEqual(
+		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") 
@@ -69,7 +69,6 @@ ALTER TABLE "stage_live"."post"
 	)
 })
 
-
 test('table-on-delete test valid', async () => {
 	const builder = createMigrationBuilder()
 	const connection = createConnectionMock([{
@@ -78,37 +77,37 @@ test('table-on-delete test valid', async () => {
 	}])
 	await migration(builder, {
 		connection: connection,
-		databaseMetadataResolver: () => Promise.resolve(createDatabaseMetadata({
-			indexes: [],
-			uniqueConstraints: [],
-			foreignKeys: [{
-				constraintName: 'fk_post_author_id_author_id',
-				fromColumn: 'author_id',
-				fromTable: 'post',
-				toColumn: 'id',
-				toTable: 'author',
-				deleteAction: ForeignKeyDeleteAction.setnull,
-				deferred: false,
-				deferrable: false,
-			}],
-		})),
-		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(),
-			},
-		})),
+		databaseMetadataResolver: () =>
+			Promise.resolve(createDatabaseMetadata({
+				indexes: [],
+				uniqueConstraints: [],
+				foreignKeys: [{
+					constraintName: 'fk_post_author_id_author_id',
+					fromColumn: 'author_id',
+					fromTable: 'post',
+					toColumn: 'id',
+					toTable: 'author',
+					deleteAction: ForeignKeyDeleteAction.setnull,
+					deferred: false,
+					deferrable: false,
+				}],
+			})),
+		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',
@@ -126,4 +125,3 @@ test('table-on-delete test valid', async () => {
 		`\n`,
 	)
 })
-