@contember/engine-content-api 1.2.1 → 1.3.0-alpha.2

package/src/mapper/update/UpdateBuilder.ts

@@ -1,10 +1,13 @@
 import { tuple } from '../../utils'
-import { Input, Model, Value } from '@contember/schema'
+import { Acl, Input, Model, Value } from '@contember/schema'
 import { acceptEveryFieldVisitor, getColumnName, getColumnType } from '@contember/schema-utils'
 import { Client, Operator, QueryBuilder, UpdateBuilder as DbUpdateBuilder, Value as DbValue } from '@contember/database'
 import { PathFactory, WhereBuilder } from '../select'
 import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
-import { AbortUpdate } from './Updater'
+import { PredicateFactory } from '../../acl'
+import { AbortDataManipulation, DataManipulationBuilder } from '../DataManipulationBuilder'
+import { AfterUpdateEvent, BeforeUpdateEvent, EventManager } from '../EventManager'
+import { Mapper } from '../Mapper'
 
 export interface UpdateResult {
 	values: ResolvedColumnValue[]
@@ -13,62 +16,71 @@ export interface UpdateResult {
 	affectedRows: number | null
 }
 
-export class UpdateBuilder {
+export class UpdateBuilder implements DataManipulationBuilder {
 	private resolver: (value: number | null) => void = () => {
 		throw new Error('UpdateBuilder: Resolver called too soon')
 	}
 	public readonly update: Promise<number | null> = new Promise(resolve => (this.resolver = resolve))
 
-	private rowData: ColumnValue<AbortUpdate>[] = []
+	private rowData: Map<string, ColumnValue<AbortDataManipulation>> = new Map()
 
-	private newWhere: Input.OptionalWhere = {}
-	private oldWhere: Input.OptionalWhere = {}
+	private newWhere: { and: Input.OptionalWhere[] } = { and: [] }
+	private oldWhere: { and: Input.OptionalWhere[] } = { and: [] }
 
 	constructor(
 		private readonly schema: Model.Schema,
 		private readonly entity: Model.Entity,
 		private readonly whereBuilder: WhereBuilder,
-		private readonly uniqueWhere: Input.Where,
+		private readonly primary: Input.PrimaryValue,
 		private readonly pathFactory: PathFactory,
+		private readonly predicateFactory: PredicateFactory,
 	) {}
 
-	public async addFieldValue(
+	public addFieldValue(
 		fieldName: string,
-		value: Value.GenericValueLike<Value.AtomicValue<AbortUpdate | undefined>>,
-	): Promise<Value.AtomicValue<AbortUpdate | undefined>> {
+		value: Value.GenericValueLike<Value.AtomicValue<AbortDataManipulation | undefined>>,
+	): Promise<Value.AtomicValue<AbortDataManipulation | undefined>> {
 		const columnName = getColumnName(this.schema, this.entity, fieldName)
 		const columnType = getColumnType(this.schema, this.entity, fieldName)
 		const resolvedValue = resolveGenericValue(value)
-		this.rowData.push({ columnName, value: resolvedValue, columnType, fieldName })
+		this.rowData.set(columnName, { columnName, value: resolvedValue, columnType, fieldName })
 		return resolvedValue
 	}
 
 	public addNewWhere(where: Input.OptionalWhere): void {
-		this.newWhere = { and: [where, this.newWhere] }
+		this.newWhere.and.push(where)
 	}
 
 	public addOldWhere(where: Input.OptionalWhere): void {
-		this.oldWhere = { and: [where, this.oldWhere] }
+		this.oldWhere.and.push(where)
 	}
 
-	public async execute(db: Client): Promise<UpdateResult> {
-		let resolvedDataFinal: ResolvedColumnValue[] | null = null
+	public addPredicates(fields: string[]): void {
+		const predicate = this.predicateFactory.create(this.entity, Acl.Operation.update, fields)
+		this.addNewWhere(predicate)
+		this.addOldWhere(predicate)
+	}
+
+	public async execute(mapper: Mapper): Promise<UpdateResult> {
 		try {
-			const resolvedData = await resolveRowData<AbortUpdate>(this.rowData)
+			const resolvedData = await resolveRowData<AbortDataManipulation>([...this.rowData.values()])
 			if (Object.keys(resolvedData).length === 0) {
 				this.resolver(null)
 				return { values: [], affectedRows: null, executed: false, aborted: false }
 			}
-			if (resolvedData.find(it => it.resolvedValue === AbortUpdate)) {
+			if (resolvedData.find(it => it.resolvedValue === AbortDataManipulation)) {
 				this.resolver(null)
 				return { values: [], affectedRows: null, executed: false, aborted: true }
 			}
+			const oldColSuffix = '_old__'
 
 			const qb = DbUpdateBuilder.create()
 				.with('newData_', qb => {
 					qb = resolvedData.reduce(
 						(qb, value) =>
-							qb.select(expr => expr.selectValue(value.resolvedValue as DbValue, value.columnType), value.columnName),
+							qb
+								.select(expr => expr.selectValue(value.resolvedValue as DbValue, value.columnType), value.columnName)
+								.select(['root_', value.columnName], value.columnName + oldColSuffix),
 						qb,
 					)
 					const columns = new Set(resolvedData.map(it => it.columnName))
@@ -90,7 +102,9 @@ export class UpdateBuilder {
 					qb = remainingColumns.reduce((qb, columnName) => qb.select(['root_', columnName]), qb)
 
 					qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([]), {
-						and: [this.uniqueWhere, this.oldWhere],
+						and: [{
+							[this.entity.primary]: { eq: this.primary },
+						}, this.oldWhere],
 					})
 
 					return qb
@@ -105,6 +119,7 @@ export class UpdateBuilder {
 						{},
 					),
 				)
+				.returning(...resolvedData.map(it => it.columnName + oldColSuffix))
 				.from(qb => {
 					qb = qb.from('newData_')
 					const col1 = tuple(this.entity.tableName, this.entity.primaryColumn)
@@ -114,9 +129,24 @@ export class UpdateBuilder {
 					return qb
 				})
 
-			const result = await qb.execute(db)
-			this.resolver(result)
-			return { values: resolvedData as ResolvedColumnValue[], affectedRows: result, executed: true, aborted: false }
+
+			const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData as ResolvedColumnValue[], this.primary)
+			await mapper.eventManager.fire(beforeEvent)
+
+			const result = await qb.execute(mapper.db)
+			this.resolver(result.length)
+
+			if (result.length === 1) {
+				const eventData = (resolvedData as ResolvedColumnValue[]).map(it => ({
+					...it,
+					old: result[0][it.columnName + oldColSuffix],
+				}))
+				const afterUpdateEvent = new AfterUpdateEvent(this.entity, eventData, this.primary)
+				beforeEvent.afterEvent = afterUpdateEvent
+				await mapper.eventManager.fire(afterUpdateEvent)
+			}
+
+			return { values: resolvedData as ResolvedColumnValue[], affectedRows: result.length, executed: true, aborted: false }
 		} catch (e) {
 			this.resolver(null)
 			throw e

package/src/mapper/update/UpdateBuilderFactory.ts

@@ -1,15 +1,24 @@
 import { PathFactory, WhereBuilder } from '../select'
 import { Input, Model } from '@contember/schema'
 import { UpdateBuilder } from './UpdateBuilder'
+import { PredicateFactory } from '../../acl'
 
 export class UpdateBuilderFactory {
 	constructor(
 		private readonly schema: Model.Schema,
 		private readonly whereBuilder: WhereBuilder,
 		private readonly pathFactory: PathFactory,
+		private readonly predicateFactory: PredicateFactory,
 	) {}
 
-	public create(entity: Model.Entity, uniqueWhere: Input.Where): UpdateBuilder {
-		return new UpdateBuilder(this.schema, entity, this.whereBuilder, uniqueWhere, this.pathFactory)
+	public create(entity: Model.Entity, primary: Input.PrimaryValue): UpdateBuilder {
+		return new UpdateBuilder(
+			this.schema,
+			entity,
+			this.whereBuilder,
+			primary,
+			this.pathFactory,
+			this.predicateFactory,
+		)
 	}
 }

package/src/mapper/update/Updater.ts

@@ -1,14 +1,12 @@
 import { SqlUpdateInputProcessor } from './SqlUpdateInputProcessor'
-import { UniqueWhereExpander, UpdateInputVisitor } from '../../inputProcessing'
-import { Acl, Input, Model } from '@contember/schema'
+import { UpdateInputVisitor } from '../../inputProcessing'
+import { Input, Model } from '@contember/schema'
 import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
 import { acceptEveryFieldVisitor } from '@contember/schema-utils'
-import { Client } from '@contember/database'
 import {
 	collectResults,
-	MutationEntryNotFoundError,
 	MutationNoResultError,
 	MutationNothingToDo,
 	MutationResultList,
@@ -34,14 +32,11 @@ export class Updater {
 		data: Input.UpdateDataInput,
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
-		const updateBuilder = this.updateBuilderFactory.create(entity, {
-			[entity.primary]: { eq: primaryValue },
-		})
+		const updateBuilder = this.updateBuilderFactory.create(entity, primaryValue)
 
 		const predicateFields = Object.keys(data)
-		this.applyPredicates(entity, predicateFields, updateBuilder)
-
-		if (filter) {
+		updateBuilder.addPredicates(predicateFields)
+		if (filter && Object.keys(filter).length > 0) {
 			updateBuilder.addOldWhere(filter)
 		}
 
@@ -50,41 +45,35 @@ export class Updater {
 		const promises = acceptEveryFieldVisitor<Promise<ResultListNotFlatten | undefined>>(this.schema, entity, visitor)
 
 		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, data, values)
-		const mutationResultPromise = Updater.executeUpdate(updateBuilder, mapper.db, okResultFactory)
-
-		return await collectResults(this.schema, mutationResultPromise, Object.values(promises))
+		const mutationResultPromise = Updater.executeUpdate(updateBuilder, mapper, okResultFactory)
+		const otherPromises = Object.values(promises)
+		if (otherPromises.length === 0) {
+			return await mutationResultPromise
+		} else {
+			return await collectResults(this.schema, mutationResultPromise, otherPromises)
+		}
 	}
 
 	public async updateCb(
 		mapper: Mapper,
 		entity: Model.Entity,
 		primaryValue: Input.PrimaryValue,
-		predicateFields: string[],
 		builderCb: (builder: UpdateBuilder) => void,
 	): Promise<MutationResultList> {
-		const updateBuilder = this.updateBuilderFactory.create(entity, {
-			[entity.primary]: { eq: primaryValue },
-		})
-		this.applyPredicates(entity, predicateFields, updateBuilder)
+		const updateBuilder = this.updateBuilderFactory.create(entity, primaryValue)
 
 		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, {}, values)
 		builderCb(updateBuilder)
 
-		return Updater.executeUpdate(updateBuilder, mapper.db, okResultFactory)
-	}
-
-	private applyPredicates(entity: Model.Entity, predicateFields: string[], updateBuilder: UpdateBuilder): void {
-		const predicateWhere = this.predicateFactory.create(entity, Acl.Operation.update, predicateFields)
-		updateBuilder.addOldWhere(predicateWhere)
-		updateBuilder.addNewWhere(predicateWhere)
+		return Updater.executeUpdate(updateBuilder, mapper, okResultFactory)
 	}
 
 	private static async executeUpdate(
 		updateBuilder: UpdateBuilder,
-		db: Client,
+		mapper: Mapper,
 		okResultFactory: (values: RowValues) => MutationUpdateOk,
 	): Promise<MutationResultList> {
-		const result = await updateBuilder.execute(db)
+		const result = await updateBuilder.execute(mapper)
 		if (result.aborted) {
 			return [new MutationNothingToDo([], NothingToDoReason.aborted)]
 		}
@@ -97,6 +86,3 @@ export class Updater {
 		return [okResultFactory(rowDataToFieldValues(result.values))]
 	}
 }
-
-export const AbortUpdate = Symbol('AbortUpdate')
-export type AbortUpdate = typeof AbortUpdate

package/src/resolvers/GraphQlQueryAstFactory.ts

@@ -19,7 +19,6 @@ type NodeFilter = (node: GraphQlFieldNode, path: string[]) => boolean
 type AnyNode = ObjectNode | FieldNode
 
 export class GraphQlQueryAstFactory {
-	constructor(private readonly argumentValuesResolver: typeof getArgumentValues) {}
 
 	public create<Args = any>(info: GraphQLResolveInfo, filter?: NodeFilter): ObjectNode<Args> {
 		const node = ResolveInfoUtils.extractFieldNode(info)
@@ -53,7 +52,7 @@ export class GraphQlQueryAstFactory {
 			name,
 			alias,
 			fields,
-			this.argumentValuesResolver(field, node, info.variableValues),
+			getArgumentValues(field, node, info.variableValues),
 			field.extensions || {},
 			path,
 		)

package/src/resolvers/MutationResolver.ts

@@ -1,5 +1,7 @@
 import { Input, Model, Result, Value } from '@contember/schema'
 import {
+	AfterCommitEvent,
+	BeforeCommitEvent,
 	ConstraintType,
 	getInsertPrimary,
 	InputErrorKind,
@@ -14,7 +16,7 @@ import { ValidationResolver } from './ValidationResolver'
 import { GraphQLResolveInfo } from 'graphql'
 import { GraphQlQueryAstFactory } from './GraphQlQueryAstFactory'
 import { ImplementationException } from '../exception'
-import { Client, Connection, retryTransaction } from '@contember/database'
+import { retryTransaction } from '@contember/database'
 import { Operation, readOperationMeta } from '../schema'
 import { assertNever } from '../utils'
 import { InputPreValidator } from '../input-validation'
@@ -29,9 +31,7 @@ type TransactionOptions = { deferForeignKeyConstraints?: boolean }
 export class MutationResolver {
 	constructor(
 		private readonly schema: Model.Schema,
-		private readonly db: Client,
 		private readonly mapperFactory: MapperFactory,
-		private readonly systemVariablesSetup: (db: Client) => Promise<void>,
 		private readonly inputValidator: InputPreValidator,
 		private readonly graphqlQueryAstFactory: GraphQlQueryAstFactory,
 	) {}
@@ -60,7 +60,7 @@ export class MutationResolver {
 					: undefined,
 			}))
 
-		return this.transaction(async (mapper, trx) => {
+		return this.transaction(async mapper => {
 			if (options?.deferForeignKeyConstraints) {
 				logger.debug('MutationResolver: deferring foreign constraints')
 				await mapper.constraintHelper.setFkConstraintsDeferred()
@@ -432,7 +432,7 @@ export class MutationResolver {
 
 		const result = await mapper.delete(entity, queryAst.args.by, queryAst.args.filter)
 		if (
-			result.length === 1 &&
+			result.length >= 1 &&
 			(result[0].result === MutationResultType.ok || result[0].result === MutationResultType.nothingToDo)
 		) {
 			return { ok: true, errors: [], ...nodes }
@@ -468,25 +468,24 @@ export class MutationResolver {
 	}
 
 	private async transaction<R extends { ok: boolean }>(
-		cb: (mapper: Mapper, db: Client<Connection.TransactionLike>) => Promise<R>,
+		cb: (mapper: Mapper) => Promise<R>,
 	): Promise<R> {
 		return await retryTransaction(
 			async () => {
-				return await this.db.transaction(async trx => {
+				const [result, mapper] = await this.mapperFactory.transaction(async mapper => {
 					logger.debug('MutationResolver: Starting mutation transaction')
-					await trx.connection.query(Connection.REPEATABLE_READ)
-					await this.systemVariablesSetup(trx)
-					const mapper = this.mapperFactory(trx)
-
-					const result = await cb(mapper, trx)
+					const result = await cb(mapper)
 					if (!result.ok) {
 						logger.debug('MutationResolver: Transaction failed, rolling back', { result })
-						await trx.connection.rollback()
+						await mapper.db.connection.rollback()
 					} else {
 						logger.debug('MutationResolver: Transaction ok, committing')
 					}
-					return result
+					await mapper.eventManager.fire(new BeforeCommitEvent())
+					return [result, mapper]
 				})
+				await mapper.eventManager.fire(new AfterCommitEvent())
+				return result
 			},
 			message => logger.warn(message),
 			{

package/src/resolvers/ReadResolver.ts

@@ -2,13 +2,11 @@ import { Input, Model } from '@contember/schema'
 import { MapperFactory } from '../mapper'
 import { GraphQLResolveInfo } from 'graphql'
 import { GraphQlQueryAstFactory } from './GraphQlQueryAstFactory'
-import { Client, Connection } from '@contember/database'
 import { ObjectNode } from '../inputProcessing'
 import { executeReadOperations, paginate } from './ReadHelpers'
 
 export class ReadResolver {
 	constructor(
-		private readonly db: Client,
 		private readonly mapperFactory: MapperFactory,
 		private readonly queryAstFactory: GraphQlQueryAstFactory,
 	) {}
@@ -16,7 +14,7 @@ export class ReadResolver {
 	public async resolveQuery(info: GraphQLResolveInfo) {
 		const queryAst = this.queryAstFactory.create(info)
 		const fields = GraphQlQueryAstFactory.resolveObjectType(info.returnType).getFields()
-		const mapper = this.mapperFactory(this.db)
+		const mapper = this.mapperFactory.create()
 		return executeReadOperations(queryAst, fields, mapper)
 	}
 
@@ -24,26 +22,24 @@ export class ReadResolver {
 		const queryAst = this.queryAstFactory.create(info)
 		const fields = GraphQlQueryAstFactory.resolveObjectType(info.returnType).getFields()
 
-		return this.db.transaction(async trx => {
-			await trx.connection.query(Connection.REPEATABLE_READ)
-			const mapper = this.mapperFactory(trx)
+		return this.mapperFactory.transaction(async mapper => {
 			return executeReadOperations(queryAst, fields, mapper)
 		})
 	}
 
 	public async resolveListQuery(entity: Model.Entity, info: GraphQLResolveInfo) {
 		const queryAst: ObjectNode<Input.ListQueryInput> = this.queryAstFactory.create(info)
-		return await this.mapperFactory(this.db).select(entity, queryAst, [])
+		return await this.mapperFactory.create().select(entity, queryAst, [])
 	}
 
 	public async resolveGetQuery(entity: Model.Entity, info: GraphQLResolveInfo) {
 		const queryAst: ObjectNode<Input.UniqueQueryInput> = this.queryAstFactory.create(info)
-		return await this.mapperFactory(this.db).selectUnique(entity, queryAst, [])
+		return await this.mapperFactory.create().selectUnique(entity, queryAst, [])
 	}
 
 	public async resolvePaginationQuery(entity: Model.Entity, info: GraphQLResolveInfo) {
 		const queryAst: ObjectNode<Input.PaginationQueryInput> = this.queryAstFactory.create(info)
-		const mapper = this.mapperFactory(this.db)
+		const mapper = this.mapperFactory.create()
 		return await paginate(mapper, entity, queryAst)
 	}
 }

package/src/resolvers/ValidationResolver.ts

@@ -1,18 +1,16 @@
 import { Input, Model, Result } from '@contember/schema'
 import { assertNever } from '../utils'
 import { InputPreValidator, ValidationResult } from '../input-validation'
-import { Client } from '@contember/database'
 import { MapperFactory } from '../mapper'
 
 export class ValidationResolver {
 	constructor(
-		private readonly db: Client,
 		private readonly mapperFactory: MapperFactory,
 		private readonly inputValidator: InputPreValidator,
 	) {}
 
 	public async validateUpdate(entity: Model.Entity, input: Input.UpdateInput): Promise<Result.ValidationResult> {
-		const mapper = this.mapperFactory(this.db)
+		const mapper = this.mapperFactory.create()
 		const validationResult = await this.inputValidator.validateUpdate({
 			mapper,
 			entity,
@@ -31,7 +29,7 @@ export class ValidationResolver {
 	}
 
 	public async validateCreate(entity: Model.Entity, input: Input.CreateInput): Promise<Result.ValidationResult> {
-		const mapper = this.mapperFactory(this.db)
+		const mapper = this.mapperFactory.create()
 		const validationResult = await this.inputValidator.validateCreate({
 			mapper,
 			entity,

package/src/resolvers/index.ts

@@ -1,4 +1,3 @@
-export * from './ExecutionContainerFactory'
 export * from './GraphQlQueryAstFactory'
 export * from './MutationResolver'
 export * from './ReadResolver'

package/src/schema/CustomTypesProvider.ts

@@ -1,34 +1,9 @@
 import { GraphQLScalarType, Kind } from 'graphql'
-import { JSONType } from '@contember/graphql-utils'
+import { JSONType, UuidType } from '@contember/graphql-utils'
 
 
-const uuidPattern = /^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$/i
-/** dashes are optional */
-const isUuid = (value: string): boolean => {
-	return (
-		value.length <= 36 &&
-		value.length >= 32 &&
-		value.match(uuidPattern) !== null
-	)
-}
-
 export class CustomTypesProvider {
-	public readonly uuidType: GraphQLScalarType = new GraphQLScalarType({
-		name: 'UUID',
-		serialize: str => String(str),
-		parseValue: str => {
-			if (typeof str !== 'string' || !isUuid(str)) {
-				return undefined
-			}
-			return str
-		},
-		parseLiteral: function parseLiteral(ast) {
-			if (ast.kind !== Kind.STRING || !isUuid(ast.value)) {
-				return undefined
-			}
-			return ast.value
-		},
-	})
+	public readonly uuidType: GraphQLScalarType = UuidType
 
 	//todo: implement serialize, parseValue and parseLiteral properly
 	public readonly dateType: GraphQLScalarType = new GraphQLScalarType({

package/src/schema/GraphQlSchemaBuilderFactory.ts

@@ -28,6 +28,7 @@ import { PaginatedFieldConfigFactory } from './PaginatedFieldConfigFactory'
 import { PaginatedHasManyFieldProvider } from '../extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
 import { PaginatedHasManyFieldProviderVisitor } from '../extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor'
 import { Builder } from '@contember/dic'
+import { ConnectOrCreateRelationInputProvider } from './mutations/ConnectOrCreateRelationInputProvider'
 
 export class GraphQlSchemaBuilderFactory {
 	constructor() {}
@@ -72,8 +73,10 @@ export class GraphQlSchemaBuilderFactory {
 				new Accessor<EntityInputProvider<EntityInputType.create>>())
 			.addService('createEntityRelationAllowedOperationsVisitor', ({ authorizator }) =>
 				new CreateEntityRelationAllowedOperationsVisitor(authorizator))
-			.addService('createEntityRelationInputFieldVisitor', ({ schema,					whereTypeProvider,					createEntityInputProviderAccessor,					createEntityRelationAllowedOperationsVisitor				}) =>
-				new CreateEntityRelationInputFieldVisitor(schema, whereTypeProvider, createEntityInputProviderAccessor, createEntityRelationAllowedOperationsVisitor))
+			.addService('connectOrCreateRelationInputProvider', ({ schema, whereTypeProvider, createEntityInputProviderAccessor }) =>
+				 new ConnectOrCreateRelationInputProvider(schema, whereTypeProvider, createEntityInputProviderAccessor))
+			.addService('createEntityRelationInputFieldVisitor', ({ schema,	whereTypeProvider, createEntityInputProviderAccessor, createEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider }) =>
+				new CreateEntityRelationInputFieldVisitor(schema, whereTypeProvider, createEntityInputProviderAccessor, createEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider))
 			.addService('createEntityRelationInputProvider', ({ schema, createEntityRelationInputFieldVisitor }) =>
 				new CreateEntityRelationInputProvider(schema, createEntityRelationInputFieldVisitor))
 			.addService('createEntityInputFieldVisitor', ({ schema, authorizator, columnTypeResolver, createEntityRelationInputProvider }) =>
@@ -84,8 +87,8 @@ export class GraphQlSchemaBuilderFactory {
 				new Accessor<EntityInputProvider<EntityInputType.update>>())
 			.addService('updateEntityRelationAllowedOperationsVisitor', ({ authorizator }) =>
 				new UpdateEntityRelationAllowedOperationsVisitor(authorizator))
-			.addService('updateEntityRelationInputFieldVisitor', ({ schema, authorizator, whereTypeProvider, updateEntityInputProviderAccessor, createEntityInputProvider, updateEntityRelationAllowedOperationsVisitor }) =>
-				new UpdateEntityRelationInputFieldVisitor(schema, authorizator, whereTypeProvider, updateEntityInputProviderAccessor, createEntityInputProvider, updateEntityRelationAllowedOperationsVisitor))
+			.addService('updateEntityRelationInputFieldVisitor', ({ schema, authorizator, whereTypeProvider, updateEntityInputProviderAccessor, createEntityInputProvider, updateEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider }) =>
+				new UpdateEntityRelationInputFieldVisitor(schema, authorizator, whereTypeProvider, updateEntityInputProviderAccessor, createEntityInputProvider, updateEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider))
 			.addService('updateEntityRelationInputProvider', ({ schema, updateEntityRelationInputFieldVisitor }) =>
 				new UpdateEntityRelationInputProvider(schema, updateEntityRelationInputFieldVisitor))
 			.addService('updateEntityInputFieldVisitor', ({ authorizator, columnTypeResolver, updateEntityRelationInputProvider }) =>

package/src/schema/MutationProvider.ts

@@ -58,7 +58,7 @@ export class MutationProvider {
 					if (parent && info.path) {
 						return parent[info.path.key]
 					}
-					return context.executionContainer.get('mutationResolver').resolveCreate(entity, info)
+					return context.executionContainer.mutationResolver.resolveCreate(entity, info)
 				})
 			},
 		}
@@ -92,7 +92,7 @@ export class MutationProvider {
 					if (parent && info.path) {
 						return parent[info.path.key]
 					}
-					return context.executionContainer.get('mutationResolver').resolveDelete(entity, info)
+					return context.executionContainer.mutationResolver.resolveDelete(entity, info)
 				})
 			},
 		}
@@ -126,7 +126,7 @@ export class MutationProvider {
 					if (parent && info.path) {
 						return parent[info.path.key]
 					}
-					return context.executionContainer.get('mutationResolver').resolveUpdate(entity, info)
+					return context.executionContainer.mutationResolver.resolveUpdate(entity, info)
 				})
 			},
 		}
@@ -165,7 +165,7 @@ export class MutationProvider {
 					if (parent && info.path) {
 						return parent[info.path.key]
 					}
-					return context.executionContainer.get('mutationResolver').resolveUpsert(entity, info)
+					return context.executionContainer.mutationResolver.resolveUpsert(entity, info)
 				})
 			},
 		}

package/src/schema/QueryProvider.ts

@@ -52,7 +52,7 @@ export class QueryProvider {
 					if (parent && info.path) {
 						return parent[info.path.key]
 					}
-					return context.executionContainer.get('readResolver').resolveGetQuery(entity, info)
+					return context.executionContainer.readResolver.resolveGetQuery(entity, info)
 				})
 			},
 		}
@@ -84,7 +84,7 @@ export class QueryProvider {
 					if (parent && info.path) {
 						return parent[info.path.key]
 					}
-					return context.executionContainer.get('readResolver').resolveListQuery(entity, info)
+					return context.executionContainer.readResolver.resolveListQuery(entity, info)
 				})
 			},
 		}
@@ -99,7 +99,7 @@ export class QueryProvider {
 					if (parent && info.path) {
 						return parent[info.path.key]
 					}
-					return context.executionContainer.get('readResolver').resolvePaginationQuery(entity, info)
+					return context.executionContainer.readResolver.resolvePaginationQuery(entity, info)
 				})
 			},
 		}

package/src/schema/mutations/ConnectOrCreateRelationInputProvider.ts

@@ -0,0 +1,54 @@
+import { Accessor, Interface, singletonFactory } from '../../utils'
+import { GraphQLInputObjectType } from 'graphql'
+import { GqlTypeName } from '../utils'
+import { WhereTypeProvider } from '../WhereTypeProvider'
+import { EntityInputProvider, EntityInputType } from './EntityInputProvider'
+import { Model } from '@contember/schema'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { ImplementationException } from '../../exception'
+
+type Args = {
+	entityName: string
+	relationName: string
+}
+
+export class ConnectOrCreateRelationInputProvider {
+	private inputs = singletonFactory<GraphQLInputObjectType, Args>(id => this.createInput(id.entityName, id.relationName))
+
+	constructor(
+		private readonly schema: Model.Schema,
+		private readonly whereTypeBuilder: WhereTypeProvider,
+		private readonly createEntityInputProviderAccessor: Accessor<Interface<EntityInputProvider<EntityInputType.create>>>,
+	) {
+	}
+
+
+	getInput(entityName: string, relationName: string) {
+		return this.inputs({ entityName, relationName })
+	}
+
+	private createInput(entityName: string, relationName: string) {
+		return acceptFieldVisitor<GraphQLInputObjectType>(this.schema, entityName, relationName, {
+			visitColumn() {
+				throw new ImplementationException()
+			},
+			visitRelation: ({ entity, targetEntity, targetRelation, relation }) => {
+				const uniqueWhere = this.whereTypeBuilder.getEntityUniqueWhereType(targetEntity.name)
+				const targetName = targetRelation ? targetRelation.name : undefined
+				const createInput = this.createEntityInputProviderAccessor.get().getInput(targetEntity.name, targetName)
+				if (!uniqueWhere || !createInput) {
+					throw new ImplementationException()
+				}
+
+				return new GraphQLInputObjectType({
+					name: GqlTypeName`${entity.name}ConnectOrCreate${relation.name}RelationInput`,
+					fields: () => ({
+						connect: { type: uniqueWhere },
+						create: { type: createInput },
+					}),
+				})
+			},
+		})
+
+	}
+}