@contember/engine-content-api 2.0.0-alpha.8 → 2.0.0-beta.1

package/src/mapper/update/relations/OneHasManyUpdateInputProcessor.ts

@@ -0,0 +1,113 @@
+import { UpdateInputProcessor } from '../../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import { Mapper } from '../../Mapper'
+import { MutationResultType } from '../../Result'
+import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
+
+type Context = Model.OneHasManyContext
+
+export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(
+		{ entity, targetEntity, targetRelation, input }: Context & { input: Input.UniqueWhere | CheckedPrimary },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.update(targetEntity, input, {
+				[targetRelation.name]: { connect: new CheckedPrimary(primary) },
+			})
+		}
+	}
+
+	public async create(
+		{ entity, targetEntity, targetRelation, input }: Context & { input: MapperInput.CreateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.insert(targetEntity, {
+				...input,
+				[targetRelation.name]: { connect: new CheckedPrimary(primary) },
+			})
+		}
+	}
+
+	public async connectOrCreate(
+		{ entity, targetRelation, targetEntity, input: { connect, create } }: Context & { input: MapperInput.ConnectOrCreateInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const connectData = {
+				[targetRelation.name]: {
+					connect: new CheckedPrimary(primary),
+				},
+			}
+			return await this.mapper.upsert(targetEntity, connect, connectData, {
+				...create,
+				...connectData,
+			})
+		}
+	}
+
+	public async update(
+		{ entity, targetEntity, targetRelation, input: { data, where } }: Context & { input: UpdateInputProcessor.UpdateManyInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.update(
+				targetEntity,
+				{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
+				{
+					...data,
+					// [targetRelation.name]: {connect: thisPrimary}
+				},
+			)
+		}
+	}
+
+	public async upsert(
+		{ entity, targetEntity, targetRelation, input: { create, update, where } }: Context & { input: UpdateInputProcessor.UpsertManyInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const result = await this.mapper.update(
+				targetEntity,
+				{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
+				{
+					...update,
+				// [targetRelation.name]: {connect: thisPrimary}
+				},
+			)
+			if (result[0].result === MutationResultType.notFoundError) {
+				return await this.mapper.insert(targetEntity, {
+					...create,
+					[targetRelation.name]: { connect: new CheckedPrimary(primary) },
+				})
+			}
+			return result
+		}
+	}
+
+	public async disconnect(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.update(
+				targetEntity,
+				{ ...input, [targetRelation.name]: { [entity.primary]: primary } },
+				{ [targetRelation.name]: { disconnect: true } },
+			)
+		}
+	}
+
+	public async delete(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.delete(targetEntity, {
+				...input,
+				[targetRelation.name]: { [entity.primary]: primary },
+			})
+		}
+	}
+}

package/src/mapper/update/relations/OneHasOneInverseUpdateInputProcessor.ts

@@ -0,0 +1,184 @@
+import {
+	ConstraintType,
+	MutationConstraintViolationError,
+	MutationNothingToDo,
+	MutationResultList,
+	MutationResultType,
+	NothingToDoReason,
+} from '../../Result'
+import { UpdateInputProcessor } from '../../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import { Mapper } from '../../Mapper'
+import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
+
+type Context = Model.OneHasOneInverseContext
+
+export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+	constructor(
+		private readonly primaryValue: Input.PrimaryValue,
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect({ input, ...ctx  }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere | CheckedPrimary }) {
+		return async () => {
+			const [newOwner, err] = await this.mapper.getPrimaryValue(ctx.targetEntity, input)
+			if (err) return [err]
+			return await this.connectInternal(ctx, newOwner)
+		}
+	}
+
+	public async connectOrCreate(
+		{ input, ...ctx }: Model.OneHasOneInverseContext & { input: MapperInput.ConnectOrCreateInput },
+	) {
+		return async () => {
+			const [newOwner] = await this.mapper.getPrimaryValue(ctx.targetEntity, input.connect)
+			if (newOwner) {
+				return await this.connectInternal(ctx, newOwner)
+			}
+			return await this.createInternal({ ...ctx, input: input.create })
+		}
+	}
+
+
+	public async create(ctx: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput }) {
+		return async () => {
+			return await this.createInternal(ctx)
+		}
+	}
+
+	public async update({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: MapperInput.UpdateDataInput }) {
+		return async () => {
+			return await this.mapper.update(
+				targetEntity,
+				{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
+				input,
+			)
+		}
+	}
+
+	public async upsert(context: Model.OneHasOneInverseContext & { input: UpdateInputProcessor.UpsertInput }) {
+		return async () => {
+			const { targetEntity, targetRelation, entity, input: { update, create } } = context
+			const result = await this.mapper.update(
+				targetEntity,
+				{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
+				update,
+			)
+			if (result[0].result === MutationResultType.notFoundError) {
+				return await this.createInternal({
+					...context,
+					input: create,
+				})
+			}
+			return result
+		}
+	}
+
+	public async disconnect({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneInverseContext & { input: undefined }) {
+		return async () => {
+			if (!relation.nullable && !targetRelation.orphanRemoval) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+			const [currentOwner] = await this.mapper.getPrimaryValue(targetEntity, {
+				[targetRelation.name]: { [entity.primary]: this.primaryValue },
+			})
+			if (!currentOwner) {
+				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+			}
+			if (currentOwner && !targetRelation.nullable) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+
+			const result = await this.mapper.updateInternal(
+				targetEntity,
+				new CheckedPrimary(currentOwner),
+				builder => {
+					builder.addPredicates([targetRelation.name])
+					builder.addFieldValue(targetRelation.name, null)
+				},
+			)
+			if (targetRelation.orphanRemoval) {
+				result.push(...(await this.mapper.delete(entity, { [entity.primary]: this.primaryValue })))
+			}
+			return result
+		}
+	}
+
+	public async delete({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneInverseContext & { input: undefined }) {
+		return async () => {
+			if (!relation.nullable && !targetRelation.orphanRemoval) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+			// orphan removal is handled in mapper.delete
+			return await this.mapper.delete(targetEntity, { [targetRelation.name]: { [entity.primary]: this.primaryValue } })
+		}
+	}
+
+	private async connectInternal(
+		{ entity, targetEntity, targetRelation }: Model.OneHasOneInverseContext,
+		newOwner: Input.PrimaryValue,
+	) {
+		const [currentOwner] = await this.mapper.getPrimaryValue(targetEntity, {
+			[targetRelation.name]: { [entity.primary]: this.primaryValue },
+		})
+		if (newOwner === currentOwner) {
+			return [new MutationNothingToDo([], NothingToDoReason.alreadyExists)]
+		}
+		const result: MutationResultList = []
+		if (currentOwner) {
+			if (!targetRelation.nullable) {
+				// todo cascade delete support?
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+			const disconnectFromCurrentOwner = await this.mapper.updateInternal(targetEntity, new CheckedPrimary(currentOwner), builder => {
+				builder.addPredicates([targetRelation.name])
+				builder.addFieldValue(targetRelation.name, null)
+			})
+			result.push(...disconnectFromCurrentOwner)
+		}
+		const orphanedInverseSide = targetRelation.orphanRemoval
+			? await this.mapper.selectField(targetEntity, { [targetEntity.primary]: newOwner }, targetRelation.name)
+			: null
+
+		const connectToNewOwner = await this.mapper.updateInternal(targetEntity, new CheckedPrimary(newOwner), builder => {
+			builder.addPredicates([targetRelation.name])
+			builder.addFieldValue(targetRelation.name, this.primaryValue)
+		})
+		result.push(...connectToNewOwner)
+
+		if (orphanedInverseSide) {
+			const deleteOrphanedInverseSide = await this.mapper.delete(entity, { [entity.primary]: orphanedInverseSide })
+			result.push(...deleteOrphanedInverseSide)
+		}
+		return result
+	}
+
+	private async createInternal({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput }) {
+		const [currentOwner] = await this.mapper.getPrimaryValue(targetEntity, {
+			[targetRelation.name]: { [entity.primary]: this.primaryValue },
+		})
+		if (currentOwner && !targetRelation.nullable) {
+			// todo cascade delete support?
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		const result: MutationResultList = []
+		if (currentOwner) {
+			const disconnectFromCurrentOwner = await this.mapper.updateInternal(targetEntity, new CheckedPrimary(currentOwner), builder => {
+				builder.addPredicates([targetRelation.name])
+				builder.addFieldValue(targetRelation.name, null)
+			})
+			result.push(...disconnectFromCurrentOwner)
+		}
+
+		const connectToNewlyCreatedOwner = await this.mapper.insert(targetEntity, input, builder => {
+			builder.addFieldValue(targetRelation.name, this.primaryValue)
+			builder.addPredicates([targetRelation.name])
+		})
+		result.push(...connectToNewlyCreatedOwner)
+
+		return result
+	}
+}

package/src/mapper/update/relations/OneHasOneOwningUpdateInputProcessor.ts

@@ -0,0 +1,240 @@
+import { UpdateInputProcessor } from '../../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import {
+	ConstraintType,
+	getInsertPrimary,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationNothingToDo,
+	MutationResultList,
+	MutationResultType,
+	NothingToDoReason,
+} from '../../Result'
+import { Mapper } from '../../Mapper'
+import { UpdateBuilder } from '../../update/UpdateBuilder'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
+import { MapperInput } from '../../types'
+
+type Context = Model.OneHasOneOwningContext
+
+export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+	constructor(
+		private readonly primaryValue: Input.PrimaryValue,
+		private readonly mapper: Mapper,
+		private readonly updateBuilder: UpdateBuilder,
+	) {
+	}
+
+	public async connect(context: Model.OneHasOneOwningContext & { input: Input.UniqueWhere | CheckedPrimary }) {
+		const { entity, relation, targetEntity, targetRelation, input } = context
+		const [newInverseSide, err] = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (err) return [err]
+		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
+		const currentOwnerResult = await this.handleStateBeforeConnect(context, currentInverseSide, newInverseSide)
+		if (currentOwnerResult.some(it => it.error)
+			|| (currentOwnerResult.length === 1 && currentOwnerResult[0].result === MutationResultType.nothingToDo)
+		) {
+			return currentOwnerResult
+		}
+
+		this.updateBuilder.addFieldValue(relation.name, newInverseSide)
+
+		return async () => {
+			return [
+				...currentOwnerResult,
+				...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
+			]
+		}
+	}
+
+	public async create(context: Model.OneHasOneOwningContext & { input: MapperInput.CreateDataInput }) {
+		const { entity, relation, targetEntity, targetRelation } = context
+		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
+		const createResult = await this.createInternal(context, currentInverseSide)
+		const newInverseSide = getInsertPrimary(createResult)
+		if (!newInverseSide) {
+			return createResult
+		}
+		this.updateBuilder.addFieldValue(relation.name, newInverseSide)
+
+		return async () => {
+			return [
+				...createResult,
+				...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
+			]
+		}
+	}
+
+	public async connectOrCreate({ input: { connect, create }, ...context }: Model.OneHasOneOwningContext & { input: MapperInput.ConnectOrCreateInput }) {
+		const { relation, targetRelation, targetEntity, entity } = context
+		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
+		const [newInverseSide] = await this.mapper.getPrimaryValue(targetEntity, connect)
+
+		if (newInverseSide) {
+			const currentOwnerResult = await this.handleStateBeforeConnect(context, currentInverseSide, newInverseSide)
+			if (currentOwnerResult.some(it => it.error)
+				|| (currentOwnerResult.length === 1 && currentOwnerResult[0].result === MutationResultType.nothingToDo)
+			) {
+				return currentOwnerResult
+			}
+			this.updateBuilder.addFieldValue(relation.name, newInverseSide)
+			return async () => {
+				return [
+					...currentOwnerResult,
+					...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
+				]
+			}
+
+		}
+
+		const createResult = await this.createInternal({ ...context, input: create }, currentInverseSide)
+		const newInverseSideCreate = getInsertPrimary(createResult)
+		if (!newInverseSideCreate) {
+			return createResult
+		}
+		this.updateBuilder.addFieldValue(relation.name, newInverseSideCreate)
+		return async () => {
+			return [
+				...createResult,
+				...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
+			]
+		}
+	}
+
+	public async update({ entity, relation, targetEntity, input }: Model.OneHasOneOwningContext & { input: MapperInput.UpdateDataInput }) {
+		return async () => {
+			const inversePrimary = await this.mapper.selectField(
+				entity,
+				{ [entity.primary]: this.primaryValue },
+				relation.name,
+			)
+			if (!inversePrimary) {
+				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+			}
+			return await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), input)
+		}
+	}
+
+	public async upsert({ entity, relation, targetEntity, input: { create, update } }: Model.OneHasOneOwningContext & { input: UpdateInputProcessor.UpsertInput }) {
+		const primary = await this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
+		if (!primary) {
+			const insertResult = await this.mapper.insert(targetEntity, create)
+			const insertPrimary = getInsertPrimary(insertResult)
+			if (!insertPrimary) {
+				return insertResult
+			}
+			this.updateBuilder.addFieldValue(relation.name, insertPrimary)
+			return []
+		}
+
+		return async () => {
+			return await this.mapper.update(targetEntity, new CheckedPrimary(primary), update)
+		}
+	}
+
+	public async disconnect({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneOwningContext & { input: undefined }) {
+		if (!relation.nullable) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		const inversePrimary = (targetRelation && !targetRelation.nullable) || relation.orphanRemoval
+			? await this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
+			: undefined
+		if (inversePrimary && targetRelation && !targetRelation.nullable && !relation.orphanRemoval) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		this.updateBuilder.addFieldValue(relation.name, null)
+
+		if (relation.orphanRemoval && inversePrimary) {
+			return async () => {
+				return await this.mapper.delete(targetEntity, new CheckedPrimary(inversePrimary))
+			}
+		}
+
+		return []
+	}
+
+	public async delete({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneOwningContext & { input: undefined }) {
+		if (!relation.nullable && relation.joiningColumn.onDelete !== Model.OnDelete.cascade) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		return async () => {
+			const targetPrimary = await this.mapper.selectField(
+				entity,
+				{ [entity.primary]: this.primaryValue },
+				relation.name,
+			)
+			if (!targetPrimary) {
+				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+			}
+			return await this.mapper.delete(targetEntity, new CheckedPrimary(targetPrimary))
+		}
+	}
+
+	private async createInternal(
+		{ targetEntity, targetRelation, relation, input }: Model.OneHasOneOwningContext & { input: MapperInput.CreateDataInput },
+		currentInverseSide: Input.PrimaryValue | undefined,
+	): Promise<MutationResultList> {
+		if (targetRelation && !targetRelation.nullable && !relation.orphanRemoval && currentInverseSide) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		return await this.mapper.insert(targetEntity, input)
+	}
+
+	private async getCurrentInverseSide(targetRelation: Model.OneHasOneInverseRelation | null, relation: Model.OneHasOneOwningRelation, entity: Model.Entity) {
+		if ((targetRelation && !targetRelation.nullable) || relation.orphanRemoval) {
+			return this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
+		}
+		return undefined
+	}
+
+	private async cleanupOrphan(relation: Model.OneHasOneOwningRelation, targetEntity: Model.Entity, currentInverseSide: Input.PrimaryValue | undefined) {
+		if (relation.orphanRemoval && currentInverseSide) {
+			return await this.mapper.delete(targetEntity, { [targetEntity.primary]: currentInverseSide })
+		}
+		return []
+	}
+
+	private async handleStateBeforeConnect(
+		{ targetEntity, targetRelation, relation, entity }: Model.OneHasOneOwningContext,
+		currentInverseSide: Input.PrimaryValue | undefined,
+		newInverseSide: Input.PrimaryValue,
+	): Promise<MutationResultList> {
+
+		if (currentInverseSide === newInverseSide) {
+			return [new MutationNothingToDo([], NothingToDoReason.alreadyExists)]
+		}
+
+		const [currentOwnerOfNewInverseSide] = await this.mapper.getPrimaryValue(entity, {
+			[relation.name]: { [targetEntity.primary]: newInverseSide },
+		})
+
+		if (currentOwnerOfNewInverseSide === this.primaryValue) {
+			return [new MutationNothingToDo([], NothingToDoReason.alreadyExists)]
+		}
+
+		// orphan removal handled bellow
+		if (targetRelation && !targetRelation.nullable && !relation.orphanRemoval && currentInverseSide) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		if (currentOwnerOfNewInverseSide) {
+			if (!relation.nullable) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+
+			return await this.mapper.updateInternal(
+				entity,
+				new CheckedPrimary(currentOwnerOfNewInverseSide),
+				builder => {
+					builder.addPredicates([relation.name])
+					builder.addFieldValue(relation.name, null)
+				},
+			)
+		}
+		return []
+	}
+}

package/src/resolvers/MutationResolver.ts

@@ -476,12 +476,15 @@ export class MutationResolver {
 						logger.debug('MutationResolver: Transaction failed, rolling back', { result })
 						await mapper.db.connection.rollback()
 					} else {
-						await mapper.eventManager.fire(new BeforeCommitEvent())
-
-						logger.debug('MutationResolver: Transaction ok, committing')
 						try {
+							await mapper.eventManager.fire(new BeforeCommitEvent())
+							logger.debug('MutationResolver: Transaction ok, committing')
 							await mapper.db.connection.commit()
+							await mapper.eventManager.fire(new AfterCommitEvent())
 						} catch (e) {
+							try {
+								await mapper.db.connection.rollback()
+							} catch {}
 							const err = convertError(this.schema, this.schemaDatabaseMetadata, e)
 							const errorResponse = this.createErrorResponse([err])
 							if (!errorResponse) {
@@ -490,7 +493,6 @@ export class MutationResolver {
 							return { ...result, ...errorResponse }
 						}
 
-						await mapper.eventManager.fire(new AfterCommitEvent())
 					}
 					return result
 				})

package/src/schema/mutations/UpdateEntityRelationInputFieldVisitor.ts

@@ -123,11 +123,16 @@ export class UpdateEntityRelationInputFieldVisitor implements Model.ColumnVisito
 			}
 			: undefined
 
+		const connectOrCreateInput = createInput && whereInputType
+			? { type: this.connectOrCreateRelationInputProvider.getInput(entity.name, relation.name) }
+			: undefined
+
 		const fields = {
 			[Input.UpdateRelationOperation.create]: createInput,
 			[Input.UpdateRelationOperation.update]: updateSpecifiedInput,
 			[Input.UpdateRelationOperation.upsert]: upsertInput,
 			[Input.UpdateRelationOperation.connect]: whereInput,
+			[Input.UpdateRelationOperation.connectOrCreate]: connectOrCreateInput,
 			[Input.UpdateRelationOperation.disconnect]: whereInput,
 			[Input.UpdateRelationOperation.delete]: whereInput,
 		}

package/tests/cases/bugs/bug-filter-or.test.ts

@@ -3,7 +3,7 @@ import { execute } from '../../src/test'
 import { GQL, SQL } from '../../src/tags'
 import { testUuid } from '../../src/testUuid'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { test } from 'vitest'
+import { test } from 'bun:test'
 
 const schema = new SchemaBuilder()
 	.entity('Location', entity =>

package/tests/cases/bugs/bug-update-by-nested-unique.test.ts

@@ -3,7 +3,7 @@ import { execute, sqlTransaction } from '../../src/test'
 import { GQL, SQL } from '../../src/tags'
 import { testUuid } from '../../src/testUuid'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { test } from 'vitest'
+import { test } from 'bun:test'
 
 const schema = new SchemaBuilder()
 	.entity('FrontPage', entity =>

package/tests/cases/bugs/bug102.test.ts

@@ -3,7 +3,7 @@ import { execute } from '../../src/test'
 import { GQL, SQL } from '../../src/tags'
 import { testUuid } from '../../src/testUuid'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { test } from 'vitest'
+import { test } from 'bun:test'
 
 test('Filter by has many with additional join', async () => {
 	await execute({

package/tests/cases/integration/graphQlRequests/delete/aclDelete.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'vitest'
+import { test } from 'bun:test'
 import { execute, failedTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'

package/tests/cases/integration/graphQlRequests/delete/additionalDeleteFilter.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'vitest'
+import { test } from 'bun:test'
 import { execute, sqlTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'

package/tests/cases/integration/graphQlRequests/delete/cascadeDelete.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'vitest'
+import { test } from 'bun:test'
 import { execute, failedTransaction, sqlTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'

package/tests/cases/integration/graphQlRequests/delete/deleteById.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'vitest'
+import { test } from 'bun:test'
 import { execute, sqlTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'

package/tests/cases/integration/graphQlRequests/delete/orphanRemoval.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'vitest'
+import { test } from 'bun:test'
 import { execute, sqlTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { GQL, SQL } from '../../../../src/tags'

package/tests/cases/integration/graphQlRequests/delete/restrictOnDelete.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'vitest'
+import { test } from 'bun:test'
 import { execute, failedTransaction, sqlTransaction } from '../../../../src/test'
 import { createSchema, SchemaBuilder, SchemaDefinition as def } from '@contember/schema-definition'
 import { Model } from '@contember/schema'

package/tests/cases/integration/graphQlRequests/delete/setNullOnDelete.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'vitest'
+import { test } from 'bun:test'
 import { execute, failedTransaction, sqlTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'

package/tests/cases/integration/graphQlRequests/insert/acl/setField.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'vitest'
+import { test } from 'bun:test'
 import { execute, failedTransaction, sqlTransaction } from '../../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Acl, Model } from '@contember/schema'

package/tests/cases/integration/graphQlRequests/insert/aclInsert.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'vitest'
+import { test } from 'bun:test'
 import { execute, sqlTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Acl, Model } from '@contember/schema'