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

package/package.json

@@ -1,30 +1,33 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.2.1",
+  "version": "1.3.0-alpha.13",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
+  "exports": {
+    "typescript": "./src/index.ts",
+    "default": "./dist/src/index.js"
+  },
   "scripts": {
-    "build-copy": "mkdir -p dist && find ./tests/ -name '*.gql' -type f -exec cp --parents {} ./dist \\;",
     "generate": "gql-gen --config graphql.codegen.yml",
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.2.1",
-    "@contember/dic": "^1.2.1",
-    "@contember/logger": "^1.2.1",
-    "@contember/graphql-utils": "^1.2.1",
-    "@contember/schema": "^1.2.1",
-    "@contember/schema-definition": "^1.2.1",
-    "@contember/schema-utils": "^1.2.1",
+    "@contember/database": "1.3.0-alpha.13",
+    "@contember/dic": "1.3.0-alpha.13",
+    "@contember/graphql-utils": "1.3.0-alpha.13",
+    "@contember/logger": "1.3.0-alpha.13",
+    "@contember/schema": "1.3.0-alpha.13",
+    "@contember/schema-definition": "1.3.0-alpha.13",
+    "@contember/schema-utils": "1.3.0-alpha.13",
     "@graphql-tools/schema": "^8.3.5",
     "fast-deep-equal": "^3.1.3",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.2.1",
-    "@contember/engine-api-tester": "^1.2.1",
-    "@contember/schema-definition": "^1.2.1",
+    "@contember/database-tester": "1.3.0-alpha.13",
+    "@contember/engine-api-tester": "1.3.0-alpha.13",
+    "@contember/schema-definition": "1.3.0-alpha.13",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",
@@ -37,4 +40,4 @@
     "graphql": ">= 14.6.0",
     "pg": "^8.9.0"
   }
-}
+}

package/src/ExecutionContainer.ts

@@ -0,0 +1,208 @@
+import { PredicateFactory, PredicatesInjector, VariableInjector } from './acl'
+import {
+	ConditionBuilder,
+	FieldsVisitorFactory,
+	JoinBuilder,
+	MetaHandler,
+	OrderByBuilder,
+	RelationFetcher,
+	WhereBuilder,
+} from './mapper/select'
+import { UniqueWhereExpander } from './inputProcessing'
+import { HasManyToHasOneReducer, HasManyToHasOneReducerExecutionHandler } from './extensions'
+import {
+	DeleteExecutor,
+	InsertBuilderFactory,
+	Inserter,
+	JunctionConnectHandler,
+	JunctionDisconnectHandler,
+	JunctionTableManager,
+	MapperFactory,
+	PathFactory,
+	SelectBuilder,
+	SelectBuilderFactory,
+	SelectHydrator,
+	UpdateBuilderFactory,
+	Updater,
+} from './mapper'
+import { Builder } from '@contember/dic'
+import { Acl, Model, Schema } from '@contember/schema'
+import { Client, SelectBuilder as DbSelectBuilder } from '@contember/database'
+import { Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { PaginatedHasManyExecutionHandler } from './extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
+import { PaginatedHasManyFieldProvider } from './extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
+import { WhereOptimizer } from './mapper/select/optimizer/WhereOptimizer'
+import { ConditionOptimizer } from './mapper/select/optimizer/ConditionOptimizer'
+import { GraphQlQueryAstFactory, MutationResolver, ReadResolver, ValidationResolver } from './resolvers'
+import {
+	ColumnValueResolver,
+	DependencyCollector,
+	EntityRulesResolver, InputPreValidator,
+	QueryAstFactory,
+	ValidationDataSelector,
+} from './input-validation'
+
+export type ExecutionContainerArgs = {
+	schema: Schema & { id: number }
+	schemaDatabaseMetadata: SchemaDatabaseMetadata
+	db: Client
+	identityId: string
+	identityVariables: Acl.VariablesMap
+	permissions: Acl.Permissions
+	systemSchema: string
+	project: { slug: string }
+	stage: { id: string; slug: string }
+}
+
+export interface ExecutionContainer {
+	readResolver: ReadResolver
+	mutationResolver: MutationResolver
+	validationResolver: ValidationResolver
+}
+
+export type ExecutionContainerBuilder = ReturnType<ExecutionContainerFactory['createBuilderInternal']>
+export type ExecutionContainerHook = (builder: ExecutionContainerBuilder) => ExecutionContainerBuilder
+
+export class ExecutionContainerFactory {
+	public readonly hooks: ExecutionContainerHook[] = []
+
+	constructor(
+		private readonly providers: Providers,
+	) {
+	}
+
+	createBuilder(args: ExecutionContainerArgs): ExecutionContainerBuilder {
+		const builder = this.createBuilderInternal(args)
+		return this.hooks.reduce((acc, cb) => cb(acc), builder)
+	}
+
+	createBuilderInternal({ permissions, identityVariables, identityId, db, schema, systemSchema, stage, project, schemaDatabaseMetadata }: ExecutionContainerArgs) {
+		return new Builder({})
+			.addService('systemSchema', () =>
+				systemSchema)
+			.addService('db', () =>
+				db)
+			.addService('project', () =>
+				project)
+			.addService('stage', () =>
+				stage)
+			.addService('schema', () =>
+				schema)
+			.addService('schemaDatabaseMetadata', () =>
+				schemaDatabaseMetadata)
+			.addService('providers', () =>
+				this.providers)
+			.addService('variableInjector', ({ schema }) =>
+				new VariableInjector(schema.model, identityVariables))
+			.addService('predicateFactory', ({ variableInjector, schema }) =>
+				new PredicateFactory(permissions, schema.model, variableInjector))
+			.addService('predicatesInjector', ({ predicateFactory, schema }) =>
+				new PredicatesInjector(schema.model, predicateFactory))
+			.addService('joinBuilder', ({ schema }) =>
+				new JoinBuilder(schema.model))
+			.addService('conditionBuilder', () =>
+				new ConditionBuilder())
+			.addService('pathFactory', () =>
+				new PathFactory())
+			.addService('whereOptimized', ({ schema }) =>
+				new WhereOptimizer(schema.model, new ConditionOptimizer()))
+			.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema }) =>
+				new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema.settings.useExistsInHasManyFilter === true))
+			.addService('orderByBuilder', ({ joinBuilder, schema }) =>
+				new OrderByBuilder(schema.model, joinBuilder))
+			.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>
+				new RelationFetcher(whereBuilder, orderByBuilder, predicatesInjector, pathFactory))
+			.addService('fieldsVisitorFactory', ({ relationFetcher, predicateFactory, whereBuilder, schema }) =>
+				new FieldsVisitorFactory(schema.model, relationFetcher, predicateFactory, whereBuilder))
+			.addService('metaHandler', ({ whereBuilder, predicateFactory }) =>
+				new MetaHandler(whereBuilder, predicateFactory))
+			.addService('uniqueWhereExpander', ({ schema }) =>
+				new UniqueWhereExpander(schema.model))
+			.addService('hasManyToHasOneReducer', ({ uniqueWhereExpander, schema }) =>
+				new HasManyToHasOneReducerExecutionHandler(schema.model, uniqueWhereExpander))
+			.addService('paginatedHasManyExecutionHandler', ({ relationFetcher, schema }) =>
+				new PaginatedHasManyExecutionHandler(schema.model, relationFetcher))
+			.addService('selectHandlers', ({ hasManyToHasOneReducer, paginatedHasManyExecutionHandler }) => ({
+				[HasManyToHasOneReducer.extensionName]: hasManyToHasOneReducer,
+				[PaginatedHasManyFieldProvider.extensionName]: paginatedHasManyExecutionHandler,
+			}))
+			.addService('selectBuilderFactory', ({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory, predicateFactory, schema }) =>
+				new (class implements SelectBuilderFactory {
+					create(qb: DbSelectBuilder, hydrator: SelectHydrator, relationPath: Model.AnyRelationContext[]): SelectBuilder {
+						return new SelectBuilder(
+							schema.model,
+							whereBuilder,
+							orderByBuilder,
+							metaHandler,
+							qb,
+							hydrator,
+							fieldsVisitorFactory,
+							selectHandlers,
+							pathFactory,
+							relationPath,
+							predicateFactory,
+						)
+					}
+				})())
+			.addService('insertBuilderFactory', ({ whereBuilder, pathFactory, schema, predicateFactory }) =>
+				new InsertBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory))
+			.addService('updateBuilderFactory', ({ whereBuilder, pathFactory, schema, predicateFactory }) =>
+				new UpdateBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory))
+			.addService('connectJunctionHandler', () =>
+				new JunctionConnectHandler())
+			.addService('disconnectJunctionHandler', ({}) =>
+				new JunctionDisconnectHandler())
+			.addService('junctionTableManager', ({ predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory, schema }) =>
+				new JunctionTableManager(schema.model, predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory))
+			.addService('deleteExecutor', ({ predicateFactory, updateBuilderFactory, whereBuilder, pathFactory, schema }) =>
+				new DeleteExecutor(schema.model, predicateFactory, whereBuilder, updateBuilderFactory, pathFactory))
+			.addService('updater', ({ predicateFactory, updateBuilderFactory, schema, schemaDatabaseMetadata }) =>
+				new Updater(schema.model, schemaDatabaseMetadata, predicateFactory, updateBuilderFactory))
+			.addService('inserter', ({  insertBuilderFactory, providers, schema, schemaDatabaseMetadata }) =>
+				new Inserter(schema.model, schemaDatabaseMetadata, insertBuilderFactory, providers))
+			.addService('mapperFactory', ({ predicatesInjector, selectBuilderFactory, uniqueWhereExpander, whereBuilder, junctionTableManager, deleteExecutor, updater, inserter, pathFactory, providers, schema, schemaDatabaseMetadata }) => {
+				return new MapperFactory(
+					db,
+					identityId,
+					schema.model,
+					schemaDatabaseMetadata,
+					predicatesInjector,
+					selectBuilderFactory,
+					uniqueWhereExpander,
+					whereBuilder,
+					junctionTableManager,
+					deleteExecutor,
+					updater,
+					inserter,
+					pathFactory,
+					providers,
+				)
+			})
+
+			.addService('queryAstFactory', () =>
+				new GraphQlQueryAstFactory())
+			.addService('readResolver', ({ mapperFactory, queryAstFactory }) =>
+				new ReadResolver(mapperFactory, queryAstFactory))
+			.addService('validationDependencyCollector', () =>
+				new DependencyCollector())
+			.addService('validationQueryAstFactory', ({ schema }) =>
+				new QueryAstFactory(schema.model))
+			.addService('dataSelector', ({ validationQueryAstFactory, schema }) =>
+				new ValidationDataSelector(schema.model, validationQueryAstFactory))
+			.addService('columnValueResolver', ({ providers }) =>
+				new ColumnValueResolver(providers))
+			.addService('entityRulesResolver', ({ schema }) =>
+				new EntityRulesResolver(schema.validation, schema.model))
+			.addService('inputPreValidator', ({ entityRulesResolver, columnValueResolver, dataSelector, schema }) =>
+				new InputPreValidator(schema.model, entityRulesResolver, columnValueResolver, dataSelector))
+			.addService('mutationResolver', ({ mapperFactory, inputPreValidator, queryAstFactory, schema, schemaDatabaseMetadata }) =>
+				new MutationResolver(schema.model, mapperFactory, inputPreValidator, queryAstFactory, schemaDatabaseMetadata))
+			.addService('validationResolver', ({ inputPreValidator, mapperFactory }) =>
+				new ValidationResolver(mapperFactory, inputPreValidator))
+	}
+
+	public create(args: ExecutionContainerArgs): ExecutionContainer {
+		return this.createBuilder(args).build().pick('validationResolver', 'readResolver', 'mutationResolver')
+	}
+}
+

package/src/acl/PermissionFactory.ts

@@ -1,33 +1,35 @@
-import { Acl, Model, Writable } from '@contember/schema'
+import { Acl, Model, Schema, Writable } from '@contember/schema'
 import { getEntity, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { mapObject } from '../utils'
 import { prefixVariable } from './VariableUtils'
 
-export class PermissionFactory {
-	constructor(private readonly schema: Model.Schema) {}
+export interface Identity {
+	projectRoles: readonly string[]
+}
 
-	public create(acl: Acl.Schema, roles: readonly string[], prefix?: string): Acl.Permissions {
+export class PermissionFactory {
+	public create(schema: Schema, roles: readonly string[], prefix?: string): Acl.Permissions {
 		let result: Acl.Permissions = {}
 		for (let role of roles) {
-			const roleDefinition = acl.roles[role] || { entities: {} }
-			let rolePermissions: Acl.Permissions = this.prefixPredicatesWithRole(roleDefinition.entities, prefix || role)
+			const roleDefinition = schema.acl.roles[role] || { entities: {} }
+			let rolePermissions: Acl.Permissions = this.prefixPredicatesWithRole(schema.model, roleDefinition.entities, prefix || role)
 			if (roleDefinition.inherits) {
-				const inheritedPermissions = this.create(acl, roleDefinition.inherits, prefix || role)
+				const inheritedPermissions = this.create(schema, roleDefinition.inherits, prefix || role)
 				rolePermissions = this.mergePermissions(inheritedPermissions, rolePermissions)
 			}
 			result = this.mergePermissions(result, rolePermissions)
 		}
-		result = this.makePrimaryPredicatesUnionOfAllFields(result)
+		result = this.makePrimaryPredicatesUnionOfAllFields(schema.model, result)
 
 		return result
 	}
 
-	private prefixPredicatesWithRole(permissions: Acl.Permissions, role: string): Acl.Permissions {
+	private prefixPredicatesWithRole(model: Model.Schema, permissions: Acl.Permissions, role: string): Acl.Permissions {
 		return mapObject(permissions, ({ operations, predicates }, entityName) => ({
 			operations,
 			predicates: mapObject(predicates, predicate => {
-				const predicateDefinitionProcessor = new PredicateDefinitionProcessor(this.schema)
-				return predicateDefinitionProcessor.process(getEntity(this.schema, entityName), predicate, {
+				const predicateDefinitionProcessor = new PredicateDefinitionProcessor(model)
+				return predicateDefinitionProcessor.process(getEntity(model, entityName), predicate, {
 					handleColumn: ({ value }) => {
 						if (typeof value === 'string') {
 							return prefixVariable(role, value)
@@ -45,9 +47,9 @@ export class PermissionFactory {
 		}))
 	}
 
-	private makePrimaryPredicatesUnionOfAllFields(permissions: Acl.Permissions): Acl.Permissions {
+	private makePrimaryPredicatesUnionOfAllFields(model: Model.Schema, permissions: Acl.Permissions): Acl.Permissions {
 		return mapObject(permissions, (permission, entityName): Acl.EntityPermissions => {
-			const entity = getEntity(this.schema, entityName)
+			const entity = getEntity(model, entityName)
 			const entityPredicates: Writable<Acl.PredicateMap> = { ...permission.predicates }
 			const entityOperations: Writable<Acl.EntityOperations> = { ...permission.operations }
 

package/src/acl/index.ts

@@ -1,6 +1,5 @@
 export * from './Authorizator'
 export * from './PermissionFactory'
-export * from './PermissionsByIdentityFactory'
 export * from './PredicateFactory'
 export * from './PredicatesInjector'
 export * from './VariableInjector'

package/src/index.ts

@@ -5,6 +5,29 @@ export * from './schema'
 export * from './inputProcessing'
 export { EntityRulesResolver } from './input-validation'
 export * from './types'
+export * from './ExecutionContainer'
 export { graphql } from 'graphql'
 export { UserError } from './exception'
-export { createMapperContainer } from './mapper'
+export {
+	DataModificationEvent,
+	AfterCommitEvent,
+	AfterInsertEvent,
+	AfterJunctionUpdateEvent,
+	AfterUpdateEvent,
+	BeforeCommitEvent,
+	BeforeDeleteEvent,
+	BeforeInsertEvent,
+	BeforeJunctionUpdateEvent,
+	BeforeUpdateEvent,
+	EventManager,
+	Mapper,
+	MapperFactory,
+	ExecutionContainer,
+	ExecutionContainerBuilder,
+	Path,
+	WhereBuilder,
+	PathFactory,
+	ExecutionContainerFactory,
+	ExecutionContainerHook,
+	ExecutionContainerArgs,
+} from './mapper'

package/src/input-validation/preValidation/CreateInputPreValidationProcessor.ts

@@ -17,29 +17,35 @@ export class CreateInputPreValidationProcessor implements CreateInputProcessor<R
 	manyHasManyInverse: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyInverseContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 
 	manyHasManyOwning: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyOwningContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 
 	manyHasOne: CreateInputProcessor.HasOneRelationProcessor<Model.ManyHasOneContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 
 	oneHasMany: CreateInputProcessor.HasManyRelationProcessor<Model.OneHasManyContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 	oneHasOneInverse: CreateInputProcessor.HasOneRelationProcessor<Model.OneHasOneInverseContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 	oneHasOneOwning: CreateInputProcessor.HasOneRelationProcessor<Model.OneHasOneOwningContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 
 	async validateCreate(context: {

package/src/input-validation/preValidation/UpdateInputPreValidationProcessor.ts

@@ -23,6 +23,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,
@@ -31,6 +32,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,
@@ -39,6 +41,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,
@@ -47,6 +50,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,
@@ -55,6 +59,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,
@@ -64,6 +69,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,

package/src/inputProcessing/CreateInputProcessor.ts

@@ -1,7 +1,7 @@
 import { Input, Model } from '@contember/schema'
 
 interface CreateInputProcessor<Result = void> {
-	column(context: CreateInputProcessor.ContextWithInput<Model.ColumnContext, Input.ColumnValue | undefined>): Promise<Result>
+	column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<Result>
 
 	manyHasManyInverse: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyInverseContext, Result>
 	manyHasManyOwning: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyOwningContext, Result>
@@ -14,21 +14,18 @@ interface CreateInputProcessor<Result = void> {
 }
 
 namespace CreateInputProcessor {
-	export type ContextWithInput<Context, Input> = Context & { input: Input }
 
 	export interface HasOneRelationProcessor<Context, Result> {
-		nothing?: (context: ContextWithInput<Context, undefined>) => Promise<Result>
-		connect: (context: ContextWithInput<Context, Input.UniqueWhere>) => Promise<Result>
-		create: (context: ContextWithInput<Context, Input.CreateDataInput>) => Promise<Result>
+		nothing?: (context: Context & { input: undefined }) => Promise<Result>
+		connect: (context: Context & { input: Input.UniqueWhere }) => Promise<Result>
+		create: (context: Context & { input: Input.CreateDataInput }) => Promise<Result>
+		connectOrCreate: (context: Context & { input: Input.ConnectOrCreateInput }) => Promise<Result>
 	}
 
 	export interface HasManyRelationProcessor<Context, Result> {
-		connect: (
-			context: ContextWithInput<Context, Input.UniqueWhere> & { index: number; alias?: string },
-		) => Promise<Result>
-		create: (
-			context: ContextWithInput<Context, Input.CreateDataInput> & { index: number; alias?: string },
-		) => Promise<Result>
+		connect: (context: Context & { input: Input.UniqueWhere } & { index: number; alias?: string }) => Promise<Result>
+		create: (context: Context & { input: Input.CreateDataInput } & { index: number; alias?: string }) => Promise<Result>
+		connectOrCreate: (context: Context & { input: Input.ConnectOrCreateInput } & { index: number; alias?: string }) => Promise<Result>
 	}
 }
 

package/src/inputProcessing/CreateInputVisitor.ts

@@ -89,6 +89,9 @@ export class CreateInputVisitor<Result> implements
 		if (isIt<Input.CreateRelationInput>(input, 'create')) {
 			return processor.create({ ...context, input: input.create })
 		}
+		if (isIt<Input.ConnectOrCreateRelationInput>(input, 'connectOrCreate')) {
+			return processor.connectOrCreate({ ...context, input: input.connectOrCreate })
+		}
 		throw new ImplementationException()
 	}
 
@@ -113,6 +116,9 @@ export class CreateInputVisitor<Result> implements
 			if (isIt<Input.CreateRelationInput>(element, 'create')) {
 				result = processor.create({ ...context, input: element.create, index: i++, alias })
 			}
+			if (isIt<Input.ConnectOrCreateRelationInput>(element, 'connectOrCreate')) {
+				result = processor.connectOrCreate({ ...context, input: element.connectOrCreate, index: i++, alias })
+			}
 			if (result !== undefined) {
 				results.push(await result)
 			}
@@ -122,9 +128,12 @@ export class CreateInputVisitor<Result> implements
 
 	private verifyOperations(input: object) {
 		const keys = Object.keys(input).filter(it => it !== 'alias')
-		if (keys.length !== 1 || !['create', 'connect'].includes(keys[0])) {
+		const ops = Object.values(Input.CreateRelationOperation) as string[]
+		if (keys.length !== 1 || !ops.includes(keys[0])) {
 			const found = keys.length === 0 ? 'none' : keys.join(', ')
-			throw new UserError(`Expected either "create" or "connect". ${found} found.`)
+			throw new UserError(
+				`Expected exactly one of: ${ops.join(', ')}. ${found} found.`,
+			)
 		}
 	}
 }

package/src/inputProcessing/UniqueWhereExpander.ts

@@ -2,13 +2,17 @@ import { Input, Model, Writable } from '@contember/schema'
 import { getTargetEntity } from '@contember/schema-utils'
 import { UserError } from '../exception'
 import { getFieldsForUniqueWhere } from '../utils'
+import { CheckedPrimary } from '../mapper/CheckedPrimary'
 
 type ExtendedUniqueWhere = Input.UniqueWhere<Input.PrimaryValue[]>
 
 export class UniqueWhereExpander {
 	constructor(private readonly schema: Model.Schema) {}
 
-	expand(entity: Model.Entity, where: ExtendedUniqueWhere, path: string[] = []): Input.Where {
+	expand(entity: Model.Entity, where: ExtendedUniqueWhere | CheckedPrimary, path: string[] = []): Input.Where {
+		if (where instanceof CheckedPrimary) {
+			return { [entity.primary]: { eq: where.primaryValue } }
+		}
 		const isFilled = (field: string) => where[field] !== undefined && where[field] !== null
 
 		const isUnique = (() => {

package/src/inputProcessing/UpdateInputProcessor.ts

@@ -1,7 +1,8 @@
 import { Input, Model } from '@contember/schema'
 
+
 interface UpdateInputProcessor<Result = void> {
-	column(context: UpdateInputProcessor.ContextWithInput<Model.ColumnContext, Input.ColumnValue | undefined>): Promise<Result>
+	column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<Result>
 
 	manyHasManyInverse: UpdateInputProcessor.HasManyRelationInputProcessor<Model.ManyHasManyInverseContext, Result>
 
@@ -17,7 +18,6 @@ interface UpdateInputProcessor<Result = void> {
 }
 
 namespace UpdateInputProcessor {
-	export type ContextWithInput<Context, Input> = Context & { input: Input }
 	export type UpsertInput = { update: Input.UpdateDataInput; create: Input.CreateDataInput }
 	export type UpdateManyInput = { where: Input.UniqueWhere; data: Input.UpdateDataInput }
 	export type UpsertManyInput = {
@@ -27,35 +27,35 @@ namespace UpdateInputProcessor {
 	}
 
 	export interface HasOneRelationInputProcessor<Context, Result> {
-		connect(context: ContextWithInput<Context, Input.UniqueWhere>): Promise<Result>
+		connect(context: Context & { input: Input.UniqueWhere }): Promise<Result>
+
+		create(context: Context & { input: Input.CreateDataInput }): Promise<Result>
 
-		create(context: ContextWithInput<Context, Input.CreateDataInput>): Promise<Result>
+		connectOrCreate(context: Context & { input: Input.ConnectOrCreateInput }): Promise<Result>
 
-		update(context: ContextWithInput<Context, Input.UpdateDataInput>): Promise<Result>
+		update(context: Context & { input: Input.UpdateDataInput }): Promise<Result>
 
-		upsert(context: ContextWithInput<Context, UpsertInput>): Promise<Result>
+		upsert(context: Context & { input: UpdateInputProcessor.UpsertInput }): Promise<Result>
 
-		disconnect(context: ContextWithInput<Context, undefined>): Promise<Result>
+		disconnect(context: Context & { input: undefined }): Promise<Result>
 
-		delete(context: ContextWithInput<Context, undefined>): Promise<Result>
+		delete(context: Context & { input: undefined }): Promise<Result>
 	}
 
 	export interface HasManyRelationInputProcessor<Context, Result> {
-		connect(context: ContextWithInput<Context, Input.UniqueWhere> & { index: number; alias?: string }): Promise<Result>
+		connect(context: Context & { input: Input.UniqueWhere; index: number; alias?: string }): Promise<Result>
+
+		create(context: Context & { input: Input.CreateDataInput; index: number; alias?: string }): Promise<Result>
 
-		create(
-			context: ContextWithInput<Context, Input.CreateDataInput> & { index: number; alias?: string },
-		): Promise<Result>
+		connectOrCreate(context: Context & { input: Input.ConnectOrCreateInput; index: number; alias?: string }): Promise<Result>
 
-		update(context: ContextWithInput<Context, UpdateManyInput> & { index: number; alias?: string }): Promise<Result>
+		update(context: Context & { input: UpdateInputProcessor.UpdateManyInput; index: number; alias?: string }): Promise<Result>
 
-		upsert(context: ContextWithInput<Context, UpsertManyInput> & { index: number; alias?: string }): Promise<Result>
+		upsert(context: Context & { input: UpdateInputProcessor.UpsertManyInput; index: number; alias?: string }): Promise<Result>
 
-		disconnect(
-			context: ContextWithInput<Context, Input.UniqueWhere> & { index: number; alias?: string },
-		): Promise<Result>
+		disconnect(context: Context & { input: Input.UniqueWhere; index: number; alias?: string }): Promise<Result>
 
-		delete(context: ContextWithInput<Context, Input.UniqueWhere> & { index: number; alias?: string }): Promise<Result>
+		delete(context: Context & { input: Input.UniqueWhere; index: number; alias?: string }): Promise<Result>
 	}
 }
 

package/src/inputProcessing/UpdateInputVisitor.ts

@@ -85,6 +85,9 @@ export class UpdateInputVisitor<Result> implements
 		if (isIt<Input.CreateRelationInput>(input, 'create')) {
 			return processor.create({ ...context, input: input.create })
 		}
+		if (isIt<Input.ConnectOrCreateRelationInput>(input, 'connectOrCreate')) {
+			return processor.connectOrCreate({ ...context, input: input.connectOrCreate })
+		}
 		if (isIt<Input.DeleteRelationInput>(input, 'delete')) {
 			return processor.delete({ ...context, input: undefined })
 		}
@@ -153,10 +156,11 @@ export class UpdateInputVisitor<Result> implements
 
 	private verifyOperations(input: object) {
 		const keys = Object.keys(input).filter(it => it !== 'alias')
-		if (keys.length !== 1 || !['create', 'connect', 'delete', 'disconnect', 'update', 'upsert'].includes(keys[0])) {
+		const ops = Object.values(Input.UpdateRelationOperation) as string[]
+		if (keys.length !== 1 || !ops.includes(keys[0])) {
 			const found = keys.length === 0 ? 'none' : keys.join(', ')
 			throw new UserError(
-				`Expected exactly one of: "create", "connect", "delete", "disconnect", "update" or "upsert". ${found} found.`,
+				`Expected exactly one of: ${ops.join(', ')}. ${found} found.`,
 			)
 		}
 	}

package/src/mapper/ColumnValue.ts

@@ -2,14 +2,14 @@ import { Value } from '@contember/schema'
 import { getFulfilledValues, getRejections } from '../utils'
 
 export type ColumnValue<E = never> = {
-	value: PromiseLike<Value.AtomicValue<E> | undefined>
+	value: PromiseLike<Value.FieldValue<E> | undefined>
 	fieldName: string
 	columnName: string
 	columnType: string
 }
 
 export type ResolvedColumnValue<E = never> = ColumnValue<E> & {
-	resolvedValue: Value.AtomicValue<E>
+	resolvedValue: Value.FieldValue<E>
 }
 
 export const resolveGenericValue = <T>(value: Value.GenericValueLike<T>): Promise<T> => {