@contember/engine-content-api 1.3.4 → 1.4.0-alpha.1

package/src/mapper/MapperFactory.ts

@@ -6,9 +6,9 @@ import { DeleteExecutor } from './delete'
 import { Updater } from './update'
 import { Inserter } from './insert'
 import { Model } from '@contember/schema'
-import { Client, Connection } from '@contember/database'
+import { Client, Connection, DatabaseMetadata } from '@contember/database'
 import { Mapper } from './Mapper'
-import { Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { Providers } from '@contember/schema-utils'
 
 export type MapperFactoryHook = (mapper: Mapper) => void
 
@@ -20,7 +20,7 @@ export class MapperFactory {
 		private readonly db: Client,
 		private readonly identityId: string,
 		private readonly schema: Model.Schema,
-		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly schemaDatabaseMetadata: DatabaseMetadata,
 		private readonly predicatesInjector: PredicatesInjector,
 		private readonly selectBuilderFactory: SelectBuilderFactory,
 		private readonly uniqueWhereExpander: UniqueWhereExpander,

package/src/mapper/Result.ts

@@ -1,9 +1,8 @@
 import { Input, Model, Value } from '@contember/schema'
 import { convertError } from './ErrorUtils'
 import { getFulfilledValues, getRejections } from '../utils'
-import { SerializationFailureError } from '@contember/database'
+import { DatabaseMetadata, SerializationFailureError } from '@contember/database'
 import { logger } from '@contember/logger'
-import { SchemaDatabaseMetadata } from '@contember/schema-utils'
 
 export enum MutationResultType {
 	ok = 'ok',
@@ -213,7 +212,7 @@ export type ResultListNotFlatten = MutationResultList | MutationResultList[]
 
 export const collectResults = async (
 	schema: Model.Schema,
-	schemaDatabaseMetadata: SchemaDatabaseMetadata,
+	schemaDatabaseMetadata: DatabaseMetadata,
 	mainPromise: Promise<ResultListNotFlatten | undefined> | undefined,
 	otherPromises: (Promise<ResultListNotFlatten | undefined> | undefined)[],
 ): Promise<MutationResultList> => {

package/src/mapper/delete/DeleteExecutor.ts

@@ -252,7 +252,7 @@ export class DeleteExecutor {
 		relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation,
 		values: Input.PrimaryValue[],
 	): Promise<void> {
-		if (mapper.constraintHelper.areFkConstraintsDeferred()) {
+		if (mapper.constraintHelper.areConstraintsDeferred('foreignKey')) {
 			return
 		}
 		const qb = this.createFetchByIdQueryBuilder(entity, relation, values)

package/src/mapper/insert/Inserter.ts

@@ -11,16 +11,17 @@ import { CreateInputVisitor } from '../../inputProcessing'
 import { SqlCreateInputProcessor } from './SqlCreateInputProcessor'
 import { Mapper } from '../Mapper'
 import { Input, Model, Value } from '@contember/schema'
-import { acceptEveryFieldVisitor, Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { acceptEveryFieldVisitor, Providers } from '@contember/schema-utils'
 import { InsertBuilderFactory } from './InsertBuilderFactory'
 import { InsertBuilder } from './InsertBuilder'
 import { tryMutation } from '../ErrorUtils'
 import { rowDataToFieldValues } from '../ColumnValue'
+import { DatabaseMetadata } from '@contember/database'
 
 export class Inserter {
 	constructor(
 		private readonly schema: Model.Schema,
-		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly schemaDatabaseMetadata: DatabaseMetadata,
 		private readonly insertBuilderFactory: InsertBuilderFactory,
 		private readonly providers: Providers,
 	) {}

package/src/mapper/select/RelationFetcher.ts

@@ -118,7 +118,7 @@ export class RelationFetcher {
 
 		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
 
-		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, relationContext.targetEntity, { filter }, [
+		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, relationContext.targetEntity, relationContext.entity, { filter }, [
 			...relationPath,
 			relationContext,
 		])
@@ -146,13 +146,14 @@ export class RelationFetcher {
 		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
 		const defaultOrderBy = relationContext.relation.orderBy
 		const objectNode = OrderByHelper.appendDefaultOrderBy(relationContext.targetEntity, field, defaultOrderBy)
-		const { targetEntity } = relationContext
+		const { targetEntity, entity } = relationContext
 		const junctionValues = await this.fetchJunction(
 			mapper.db,
 			owningRelation,
 			ids,
 			joiningColumns,
 			targetEntity,
+			entity,
 			objectNode,
 			[...relationPath, relationContext],
 		)
@@ -219,11 +220,12 @@ export class RelationFetcher {
 		values: Input.PrimaryValue[],
 		column: JoiningColumns,
 		targetEntity: Model.Entity,
+		sourceEntity: Model.Entity,
 		object: ObjectNode<Input.ListQueryInput>,
 		relationPath: Model.AnyRelationContext[],
 	): Promise<Record<string, Value.AtomicValue>[]> {
 		const joiningTable = relation.joiningTable
-		const qb = this.buildJunctionQb(relation, values, column, targetEntity, object.args, relationPath)
+		const qb = this.buildJunctionQb(relation, values, column, targetEntity, sourceEntity, object.args, relationPath)
 			.select(['junction_', joiningTable.inverseJoiningColumn.columnName])
 			.select(['junction_', joiningTable.joiningColumn.columnName])
 		const wrapper = new LimitByGroupWrapper(
@@ -252,15 +254,17 @@ export class RelationFetcher {
 		ids: Input.PrimaryValue[],
 		column: JoiningColumns,
 		targetEntity: Model.Entity,
+		sourceEntity: Model.Entity,
 		objectArgs: Input.ListQueryInput,
 		relationPath: Model.AnyRelationContext[],
 	): SelectBuilder {
 		const joiningTable = relation.joiningTable
 
 		const whereColumn = column.sourceColumn.columnName
+		const primaryColumn = sourceEntity.fields[sourceEntity.primary] as Model.AnyColumn
 		let qb = SelectBuilder.create()
 			.from(joiningTable.tableName, 'junction_')
-			.where(clause => clause.in(['junction_', whereColumn], ids))
+			.where(clause => clause.in(['junction_', whereColumn], ids, primaryColumn.columnType))
 
 		const where = this.predicateInjector.inject(targetEntity, objectArgs.filter || {}, relationPath[relationPath.length - 1])
 		const hasWhere = where && Object.keys(where).length > 0

package/src/mapper/select/handlers/FieldsVisitor.ts

@@ -1,19 +1,18 @@
-import { Acl, Input, Model } from '@contember/schema'
+import { Acl, Input, Model, Settings } from '@contember/schema'
 import { Mapper } from '../../Mapper'
 import { RelationFetcher } from '../RelationFetcher'
 import { SelectExecutionHandlerContext } from '../SelectExecutionHandler'
 import { PredicateFactory } from '../../../acl'
-import { WhereBuilder } from '../WhereBuilder'
+import { Literal, wrapIdentifier } from '@contember/database'
 
 export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.ColumnVisitor<void> {
 	constructor(
-		private readonly schema: Model.Schema,
 		private readonly relationFetcher: RelationFetcher,
 		private readonly predicateFactory: PredicateFactory,
-		private readonly whereBuilder: WhereBuilder,
 		private readonly mapper: Mapper,
 		private readonly executionContext: SelectExecutionHandlerContext,
 		private readonly relationPath: Model.AnyRelationContext[],
+		private readonly settings: Settings.ContentSettings,
 	) {}
 
 	visitColumn({ entity, column }: Model.ColumnContext): void {
@@ -21,8 +20,13 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		const tableAlias = columnPath.back().alias
 		const columnAlias = columnPath.alias
 
+		let selectFrom = wrapIdentifier(tableAlias) + '.' + wrapIdentifier(column.columnName)
+		if (column.type === Model.ColumnType.Date && this.settings.shortDateResponse) {
+			selectFrom += '::text'
+		}
+
 		this.executionContext.addColumn({
-			query: qb => qb.select([tableAlias, column.columnName], columnAlias),
+			query: qb => qb.select(new Literal(selectFrom), columnAlias),
 			predicate: this.getRequiredPredicate(entity, column),
 		})
 	}

package/src/mapper/select/handlers/FieldsVisitorFactory.ts

@@ -1,28 +1,25 @@
 import { FieldsVisitor } from './FieldsVisitor'
 import { RelationFetcher } from '../RelationFetcher'
-import { Model } from '@contember/schema'
 import { Mapper } from '../../Mapper'
 import { SelectExecutionHandlerContext } from '../SelectExecutionHandler'
 import { PredicateFactory } from '../../../acl'
-import { WhereBuilder } from '../WhereBuilder'
+import { Settings } from '@contember/schema'
 
 export class FieldsVisitorFactory {
 	constructor(
-		private readonly schema: Model.Schema,
 		private readonly relationFetcher: RelationFetcher,
 		private readonly predicateFactory: PredicateFactory,
-		private readonly whereBuilder: WhereBuilder,
+		private readonly settings: Settings.ContentSettings,
 	) {}
 
 	create(mapper: Mapper, context: SelectExecutionHandlerContext): FieldsVisitor {
 		return new FieldsVisitor(
-			this.schema,
 			this.relationFetcher,
 			this.predicateFactory,
-			this.whereBuilder,
 			mapper,
 			context,
 			context.relationPath,
+			this.settings,
 		)
 	}
 }

package/src/mapper/update/Updater.ts

@@ -4,7 +4,7 @@ import { Input, Model } from '@contember/schema'
 import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
-import { acceptEveryFieldVisitor, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { acceptEveryFieldVisitor } from '@contember/schema-utils'
 import {
 	collectResults,
 	MutationNoResultError,
@@ -17,11 +17,12 @@ import {
 } from '../Result'
 import { UpdateBuilder } from './UpdateBuilder'
 import { rowDataToFieldValues } from '../ColumnValue'
+import { DatabaseMetadata } from '@contember/database'
 
 export class Updater {
 	constructor(
 		private readonly schema: Model.Schema,
-		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly schemaDatabaseMetadata: DatabaseMetadata,
 		private readonly predicateFactory: PredicateFactory,
 		private readonly updateBuilderFactory: UpdateBuilderFactory,
 	) {}

package/src/resolvers/MutationResolver.ts

@@ -3,6 +3,7 @@ import {
 	AfterCommitEvent,
 	BeforeCommitEvent,
 	ConstraintType,
+	convertError,
 	getInsertPrimary,
 	InputErrorKind,
 	Mapper,
@@ -16,18 +17,20 @@ import { ValidationResolver } from './ValidationResolver'
 import { GraphQLResolveInfo } from 'graphql'
 import { GraphQlQueryAstFactory } from './GraphQlQueryAstFactory'
 import { ImplementationException } from '../exception'
-import { retryTransaction } from '@contember/database'
+import { DatabaseMetadata, retryTransaction } from '@contember/database'
 import { Operation, readOperationMeta } from '../schema'
 import { assertNever } from '../utils'
 import { InputPreValidator } from '../input-validation'
 import { ObjectNode } from '../inputProcessing'
 import { executeReadOperations } from './ReadHelpers'
 import { logger } from '@contember/logger'
-import { SchemaDatabaseMetadata } from '@contember/schema-utils'
 
 type WithoutNode<T extends { node: any }> = Pick<T, Exclude<keyof T, 'node'>>
 
-type TransactionOptions = { deferForeignKeyConstraints?: boolean }
+type TransactionOptions = {
+	deferForeignKeyConstraints?: boolean
+	deferUniqueConstraints?: boolean
+}
 
 export class MutationResolver {
 	constructor(
@@ -35,7 +38,7 @@ export class MutationResolver {
 		private readonly mapperFactory: MapperFactory,
 		private readonly inputValidator: InputPreValidator,
 		private readonly graphqlQueryAstFactory: GraphQlQueryAstFactory,
-		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly schemaDatabaseMetadata: DatabaseMetadata,
 	) {}
 
 	public async resolveTransaction(info: GraphQLResolveInfo, options: TransactionOptions): Promise<Result.TransactionResult> {
@@ -65,7 +68,11 @@ export class MutationResolver {
 		return this.transaction(async mapper => {
 			if (options?.deferForeignKeyConstraints) {
 				logger.debug('MutationResolver: deferring foreign constraints')
-				await mapper.constraintHelper.setFkConstraintsDeferred()
+				await mapper.constraintHelper.setConstraintsDeferred('foreignKey')
+			}
+			if (options?.deferUniqueConstraints) {
+				logger.debug('MutationResolver: deferring unique constraints')
+				await mapper.constraintHelper.setConstraintsDeferred('unique')
 			}
 			const validationResult: Record<string, Result.MutationFieldResult> = {}
 			const validationErrors: Result.ValidationError[] = []
@@ -196,18 +203,6 @@ export class MutationResolver {
 				}
 				trxResult[field.alias] = result
 			}
-			if (options?.deferForeignKeyConstraints) {
-				logger.debug('MutationResolver: validating fk constraints')
-				const constraintsResult = await tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
-					await mapper.constraintHelper.setFkConstraintsImmediate()
-					return []
-				})
-				const errorResponse = this.createErrorResponse(constraintsResult)
-				if (errorResponse) {
-					logger.debug('MutationResolver: deferred fk validation failed', { errorResponse })
-					return { ...errorResponse, ...validationResult }
-				}
-			}
 
 			return {
 				__typename: 'MutationTransaction',
@@ -474,20 +469,31 @@ export class MutationResolver {
 	): Promise<R> {
 		return await retryTransaction(
 			async () => {
-				const [result, mapper] = await this.mapperFactory.transaction(async mapper => {
+				return await this.mapperFactory.transaction(async mapper => {
 					logger.debug('MutationResolver: Starting mutation transaction')
 					const result = await cb(mapper)
 					if (!result.ok) {
 						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.db.connection.commit()
+						} catch (e) {
+							const err = convertError(this.schema, this.schemaDatabaseMetadata, e)
+							const errorResponse = this.createErrorResponse([err])
+							if (!errorResponse) {
+								throw new ImplementationException()
+							}
+							return { ...result, ...errorResponse }
+						}
+
+						await mapper.eventManager.fire(new AfterCommitEvent())
 					}
-					await mapper.eventManager.fire(new BeforeCommitEvent())
-					return [result, mapper]
+					return result
 				})
-				await mapper.eventManager.fire(new AfterCommitEvent())
-				return result
 			},
 			message => logger.warn(message),
 			{
@@ -496,6 +502,7 @@ export class MutationResolver {
 				maxTimeout: 1000,
 			},
 		)
+
 	}
 
 	private createErrorResponse(result: MutationResultList) {

package/src/schema/EntityTypeProvider.ts

@@ -46,7 +46,8 @@ export class EntityTypeProvider {
 		private readonly columnTypeResolver: ColumnTypeResolver,
 		private readonly whereTypeProvider: WhereTypeProvider,
 		private readonly orderByTypeProvider: OrderByTypeProvider,
-	) {}
+	) {
+	}
 
 	public registerEntityFieldProvider(key: string, provider: EntityFieldsProvider): void {
 		this.entityFieldProviders[key] = provider
@@ -76,19 +77,16 @@ export class EntityTypeProvider {
 	private getEntityFields(entityName: string) {
 		const entity = getEntityFromSchema(this.schema, entityName)
 		const accessVisitor = new FieldAccessVisitor(Acl.Operation.read, this.authorizator)
-		const accessibleFields = Object.keys(entity.fields).filter(fieldName =>
-			acceptFieldVisitor(this.schema, entity, fieldName, accessVisitor),
-		)
-		const metaFields: { [field: string]: GraphQLFieldConfig<any, any> } = accessibleFields.reduce(
-			(result, fieldName) => ({
-				...result,
-				[fieldName]: {
-					type: this.fieldMeta,
-					resolve: aliasAwareResolver,
-				},
-			}),
-			{},
+		const accessibleFields = Object.values(entity.fields).filter(field =>
+			acceptFieldVisitor(this.schema, entity, field.name, accessVisitor),
 		)
+		const metaFields: { [field: string]: GraphQLFieldConfig<any, any> } = {}
+		for (const field of accessibleFields) {
+			metaFields[field.name] = {
+				type: this.fieldMeta,
+				resolve: aliasAwareResolver,
+			}
+		}
 
 		const metaField = {
 			type: new GraphQLObjectType({
@@ -98,36 +96,29 @@ export class EntityTypeProvider {
 			resolve: aliasAwareResolver,
 		}
 
-		const fields: { [field: string]: GraphQLFieldConfig<any, any> } = accessibleFields.reduce(
-			(result, fieldName) => {
-				const fieldTypeVisitor = new FieldTypeVisitor(this.columnTypeResolver, this, this.authorizator)
-				const type: GraphQLOutputType = acceptFieldVisitor(this.schema, entity, fieldName, fieldTypeVisitor)
+		let fields: { [field: string]: GraphQLFieldConfig<any, any> } = {
+			_meta: metaField,
+		}
+
+		for (const field of accessibleFields) {
+			const fieldTypeVisitor = new FieldTypeVisitor(this.columnTypeResolver, this, this.authorizator)
+			const type: GraphQLOutputType = acceptFieldVisitor(this.schema, entity, field.name, fieldTypeVisitor)
 
-				const fieldArgsVisitor = new FieldArgsVisitor(this.whereTypeProvider, this.orderByTypeProvider)
-				return {
-					...result,
-					[fieldName]: {
-						type,
-						args: acceptFieldVisitor(this.schema, entity, fieldName, fieldArgsVisitor),
-						resolve: aliasAwareResolver,
-					},
-				}
-			},
-			{
-				_meta: metaField,
-			},
-		)
+			const fieldArgsVisitor = new FieldArgsVisitor(this.whereTypeProvider, this.orderByTypeProvider)
+			fields[field.name] = {
+				type,
+				args: acceptFieldVisitor(this.schema, entity, field.name, fieldArgsVisitor),
+				resolve: aliasAwareResolver,
+			}
+		}
 
-		return Object.entries(this.entityFieldProviders)
-			.map(([key, provider]) =>
-				Object.entries(provider.getFields(entity, accessibleFields))
-					.map(([fieldName, fieldConfig]): [string, GraphQLFieldConfig<any, any>] => [
-						fieldName,
-						{ ...fieldConfig, extensions: { ...(fieldConfig.extensions || {}), extensionKey: key } },
-					])
-					.reduce((result, [name, value]) => ({ ...result, [name]: value }), {}),
-			)
-			.reduce((result, providerFields) => ({ ...result, ...providerFields }), fields)
+		for (const [key, provider] of Object.entries(this.entityFieldProviders)) {
+			fields = {
+				...fields,
+				...provider.getFields(entity, accessibleFields),
+			}
+		}
+		return fields
 	}
 
 	private createConnection(entityName: string) {

package/src/schema/GraphQlSchemaBuilder.ts

@@ -1,10 +1,13 @@
 import {
-	GraphQLFieldConfig,
 	GraphQLBoolean,
+	GraphQLFieldConfig,
+	GraphQLInputObjectType,
+	GraphQLNamedType,
 	GraphQLNonNull,
 	GraphQLObjectType,
 	GraphQLSchema,
-	GraphQLString, GraphQLInputObjectType,
+	GraphQLSchemaConfig,
+	GraphQLString,
 } from 'graphql'
 import { Model } from '@contember/schema'
 import { MutationProvider } from './MutationProvider'
@@ -13,6 +16,12 @@ import { ValidationQueriesProvider } from './ValidationQueriesProvider'
 import { Context } from '../types'
 import { ResultSchemaTypeProvider } from './ResultSchemaTypeProvider'
 
+type BuildArgs = {
+	queries?: Map<string, GraphQLFieldConfig<any, Context, any>>
+	mutations?: Map<string, GraphQLFieldConfig<any, Context, any>>
+	types?: GraphQLNamedType[]
+}
+
 export class GraphQlSchemaBuilder {
 	constructor(
 		private readonly schema: Model.Schema,
@@ -22,9 +31,13 @@ export class GraphQlSchemaBuilder {
 		private readonly resultSchemaTypeProvider: ResultSchemaTypeProvider,
 	) {}
 
-	public build(): GraphQLSchema {
-		const queries = new Map<string, GraphQLFieldConfig<any, Context, any>>()
-		const mutations = new Map<string, GraphQLFieldConfig<any, Context, any>>()
+	public build(args: BuildArgs = {}): GraphQLSchema {
+		return new GraphQLSchema(this.buildConfig(args))
+	}
+
+	private buildConfig(args: BuildArgs): GraphQLSchemaConfig {
+		const queries = new Map<string, GraphQLFieldConfig<any, Context, any>>(args.queries)
+		const mutations = new Map<string, GraphQLFieldConfig<any, Context, any>>(args.mutations)
 		for (const entity of Object.values(this.schema.entities)) {
 			const queryFields = this.queryProvider.getQueries(entity)
 			for (const name in queryFields) {
@@ -41,11 +54,12 @@ export class GraphQlSchemaBuilder {
 		}
 
 		if (queries.size > 0) {
+			const queryTransactionType = new GraphQLObjectType({
+				name: 'QueryTransaction',
+				fields: Object.fromEntries(queries),
+			})
 			queries.set('transaction', {
-				type: new GraphQLObjectType({
-					name: 'QueryTransaction',
-					fields: Object.fromEntries(queries),
-				}),
+				type: queryTransactionType,
 				resolve: async (parent, args, context: Context, info) => {
 					return context.timer(`GraphQL.query.${info.fieldName}`, () =>
 						context.executionContainer.readResolver.resolveTransaction(info),
@@ -58,38 +72,42 @@ export class GraphQlSchemaBuilder {
 			fields: () => Object.fromEntries(queries),
 		})
 		if (mutations.size > 0) {
+			const mutationTransactionOptions = new GraphQLInputObjectType({
+				name: 'MutationTransactionOptions',
+				fields: {
+					deferForeignKeyConstraints: { type: GraphQLBoolean },
+					deferUniqueConstraints: { type: GraphQLBoolean },
+				},
+			})
+			const mutationTransactionType = new GraphQLObjectType({
+				name: 'MutationTransaction',
+				fields: {
+					ok: { type: new GraphQLNonNull(GraphQLBoolean) },
+					errorMessage: { type: GraphQLString },
+					errors: { type: this.resultSchemaTypeProvider.errorListResultType },
+					validation: {
+						type: new GraphQLNonNull(this.resultSchemaTypeProvider.validationResultType),
+					},
+					...Object.fromEntries(mutations),
+					query: {
+						type: queryObjectType,
+					},
+				},
+			})
 			mutations.set('transaction', {
 				args: {
 					options: {
-						type: new GraphQLInputObjectType({
-							name: 'MutationTransactionOptions',
-							fields: {
-								deferForeignKeyConstraints: { type: GraphQLBoolean },
-							},
-						}),
+						type: mutationTransactionOptions,
 					},
 				},
 				type: new GraphQLNonNull(
-					new GraphQLObjectType({
-						name: 'MutationTransaction',
-						fields: {
-							ok: { type: new GraphQLNonNull(GraphQLBoolean) },
-							errorMessage: { type: GraphQLString },
-							errors: { type: this.resultSchemaTypeProvider.errorListResultType },
-							validation: {
-								type: new GraphQLNonNull(this.resultSchemaTypeProvider.validationResultType),
-							},
-							...Object.fromEntries(mutations),
-							query: {
-								type: queryObjectType,
-							},
-						},
-					}),
+					mutationTransactionType,
 				),
-				resolve: async (parent, args: { options?: { deferForeignKeyConstraints?: boolean } }, context: Context, info) => {
+				resolve: async (parent, args: { options?: { deferForeignKeyConstraints?: boolean; deferUniqueConstraints?: boolean } }, context: Context, info) => {
 					return context.timer(`GraphQL.mutation.${info.fieldName}`, () =>
 						context.executionContainer.mutationResolver.resolveTransaction(info, {
 							deferForeignKeyConstraints: args.options?.deferForeignKeyConstraints ?? false,
+							deferUniqueConstraints: args.options?.deferUniqueConstraints ?? false,
 						}),
 					)
 				},
@@ -99,28 +117,31 @@ export class GraphQlSchemaBuilder {
 				resolve: (parent, args, context: Context, info) => context.executionContainer.readResolver.resolveQuery(info),
 			})
 		}
-		queries.set('_info', {
-			type: new GraphQLObjectType({
-				name: 'Info',
-				fields: () => ({
-					description: { type: GraphQLString },
-				}),
+		const infoType = new GraphQLObjectType({
+			name: 'Info',
+			fields: () => ({
+				description: { type: GraphQLString },
 			}),
+		})
+		queries.set('_info', {
+			type: infoType,
 			resolve: () => ({
 				description: 'TODO',
 			}),
 		})
 
-		return new GraphQLSchema({
+
+		return {
 			query: queryObjectType,
+			types: args.types,
 			...(mutations.size > 0
 				? {
 					mutation: new GraphQLObjectType({
 						name: 'Mutation',
 						fields: () => Object.fromEntries(mutations),
 					}),
-				  }
+				}
 				: {}),
-		})
+		}
 	}
 }