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

package/src/mapper/index.ts

@@ -5,9 +5,11 @@ export * from './update'
 export * from './ColumnValue'
 export * from './Constraints'
 export * from './ErrorUtils'
+export * from './EventManager'
 export * from './JunctionTableManager'
 export * from './Mapper'
-export * from './MapperContainer'
+export * from '../ExecutionContainer'
+export * from './MapperFactory'
 export * from './MutationProcessorHelper'
 export * from './Result'
 export * from './types'

package/src/mapper/insert/InsertBuilder.ts

@@ -6,6 +6,8 @@ import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData }
 import { ImplementationException } from '../../exception'
 import { PredicateFactory } from '../../acl'
 import { AbortDataManipulation, DataManipulationBuilder } from '../DataManipulationBuilder'
+import { AfterInsertEvent, BeforeInsertEvent, EventManager } from '../EventManager'
+import { Mapper } from '../Mapper'
 
 export interface InsertResult {
 	values: ResolvedColumnValue[]
@@ -55,7 +57,7 @@ export class InsertBuilder implements DataManipulationBuilder {
 		return resolveRowData([...this.rowData.values()])
 	}
 
-	public async execute(db: Client): Promise<InsertResult> {
+	public async execute(mapper: Mapper): Promise<InsertResult> {
 		try {
 			const resolvedData = await this.getResolvedData()
 			if (resolvedData.find(it => it.resolvedValue === AbortDataManipulation)) {
@@ -83,8 +85,16 @@ export class InsertBuilder implements DataManipulationBuilder {
 				})
 				.returning(this.entity.primaryColumn)
 
-			const returning = (await qb.execute(db)).map(it => it[this.entity.primaryColumn])
+			const beforeInsertEvent = new BeforeInsertEvent(this.entity, resolvedData as ResolvedColumnValue[])
+			await mapper.eventManager.fire(beforeInsertEvent)
+
+			const returning = (await qb.execute(mapper.db)).map(it => it[this.entity.primaryColumn])
 			const result = returning.length === 1 ? returning[0] : null
+
+			const afterInsertEvent = new AfterInsertEvent(this.entity, resolvedData as ResolvedColumnValue[], result)
+			beforeInsertEvent.afterEvent = afterInsertEvent
+			await mapper.eventManager.fire(afterInsertEvent)
+
 			this.resolver(result)
 			return { values: resolvedData as ResolvedColumnValue[], executed: true, primaryValue: result, aborted: false }
 		} catch (e) {

package/src/mapper/insert/Inserter.ts

@@ -11,9 +11,8 @@ import { CreateInputVisitor } from '../../inputProcessing'
 import { SqlCreateInputProcessor } from './SqlCreateInputProcessor'
 import { Mapper } from '../Mapper'
 import { Input, Model, Value } from '@contember/schema'
-import { acceptEveryFieldVisitor, Providers } from '@contember/schema-utils'
+import { acceptEveryFieldVisitor, Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
 import { InsertBuilderFactory } from './InsertBuilderFactory'
-import { Client } from '@contember/database'
 import { InsertBuilder } from './InsertBuilder'
 import { tryMutation } from '../ErrorUtils'
 import { rowDataToFieldValues } from '../ColumnValue'
@@ -21,6 +20,7 @@ import { rowDataToFieldValues } from '../ColumnValue'
 export class Inserter {
 	constructor(
 		private readonly schema: Model.Schema,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 		private readonly insertBuilderFactory: InsertBuilderFactory,
 		private readonly providers: Providers,
 	) {}
@@ -51,18 +51,18 @@ export class Inserter {
 
 		const okResultFactory = (primary: Value.PrimaryValue, values: RowValues) =>
 			new MutationCreateOk([], entity, primary, data, values)
-		const insertPromise = this.executeInsert(insertBuilder, mapper.db, okResultFactory)
+		const insertPromise = this.executeInsert(insertBuilder, mapper, okResultFactory)
 
-		return await collectResults(this.schema, insertPromise, Object.values(promises))
+		return await collectResults(this.schema, this.schemaDatabaseMetadata, insertPromise, Object.values(promises))
 	}
 
 	private async executeInsert(
 		insertBuilder: InsertBuilder,
-		db: Client,
+		mapper: Mapper,
 		okResultFactory: (primary: Value.PrimaryValue, values: RowValues) => MutationCreateOk,
 	): Promise<MutationResultList> {
-		return tryMutation(this.schema, async () => {
-			const result = await insertBuilder.execute(db)
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
+			const result = await insertBuilder.execute(mapper)
 			if (result.aborted) {
 				return [new MutationNothingToDo([], NothingToDoReason.aborted)]
 			}

package/src/mapper/select/OrderByHelper.ts

@@ -5,10 +5,11 @@ export class OrderByHelper {
 	public static appendDefaultOrderBy(
 		entity: Model.Entity,
 		objectNode: ObjectNode<Input.ListQueryInput>,
-		defaultOrderBy: readonly Model.OrderBy[],
+		relationOrderBy: readonly Model.OrderBy[] | undefined,
 	): ObjectNode<Input.ListQueryInput> {
 		const inputOrder = objectNode.args.orderBy || []
 		const hasOrderBy = inputOrder.length > 0
+		const defaultOrderBy = relationOrderBy ?? entity.orderBy ?? []
 		if (!hasOrderBy && defaultOrderBy.length > 0) {
 			const defaultOrderByWithPrimary = [...defaultOrderBy, ...this.getPrimaryOrderBy(inputOrder, entity)]
 			return objectNode.withArg('orderBy', this.buildOrderBy(defaultOrderByWithPrimary))

package/src/mapper/select/RelationFetcher.ts

@@ -83,7 +83,7 @@ export class RelationFetcher {
 		const objectNodeWithOrder = OrderByHelper.appendDefaultOrderBy(
 			targetEntity,
 			objectNodeWithWhere,
-			relation.orderBy || [],
+			relation.orderBy,
 		)
 
 		return mapper.selectGrouped(targetEntity, objectNodeWithOrder, targetRelation, [
@@ -144,7 +144,7 @@ export class RelationFetcher {
 	}: FetchManyHasManyGroupsArgs): Promise<SelectGroupedObjects> {
 		const owningRelation = relationContext.type === 'manyHasManyInverse' ? relationContext.targetRelation : relationContext.relation
 		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
-		const defaultOrderBy = relationContext.relation.orderBy || []
+		const defaultOrderBy = relationContext.relation.orderBy
 		const objectNode = OrderByHelper.appendDefaultOrderBy(relationContext.targetEntity, field, defaultOrderBy)
 		const { targetEntity } = relationContext
 		const junctionValues = await this.fetchJunction(

package/src/mapper/update/UpdateBuilder.ts

@@ -6,6 +6,8 @@ import { PathFactory, WhereBuilder } from '../select'
 import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
 import { PredicateFactory } from '../../acl'
 import { AbortDataManipulation, DataManipulationBuilder } from '../DataManipulationBuilder'
+import { AfterUpdateEvent, BeforeUpdateEvent, EventManager } from '../EventManager'
+import { Mapper } from '../Mapper'
 
 export interface UpdateResult {
 	values: ResolvedColumnValue[]
@@ -29,7 +31,7 @@ export class UpdateBuilder implements DataManipulationBuilder {
 		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,
 	) {}
@@ -59,7 +61,7 @@ export class UpdateBuilder implements DataManipulationBuilder {
 		this.addOldWhere(predicate)
 	}
 
-	public async execute(db: Client): Promise<UpdateResult> {
+	public async execute(mapper: Mapper): Promise<UpdateResult> {
 		try {
 			const resolvedData = await resolveRowData<AbortDataManipulation>([...this.rowData.values()])
 			if (Object.keys(resolvedData).length === 0) {
@@ -70,12 +72,15 @@ export class UpdateBuilder implements DataManipulationBuilder {
 				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))
@@ -97,7 +102,9 @@ export class UpdateBuilder implements DataManipulationBuilder {
 					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
@@ -112,6 +119,7 @@ export class UpdateBuilder implements DataManipulationBuilder {
 						{},
 					),
 				)
+				.returning(...resolvedData.map(it => it.columnName + oldColSuffix))
 				.from(qb => {
 					qb = qb.from('newData_')
 					const col1 = tuple(this.entity.tableName, this.entity.primaryColumn)
@@ -121,9 +129,24 @@ export class UpdateBuilder implements DataManipulationBuilder {
 					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

@@ -11,12 +11,12 @@ export class UpdateBuilderFactory {
 		private readonly predicateFactory: PredicateFactory,
 	) {}
 
-	public create(entity: Model.Entity, uniqueWhere: Input.Where): UpdateBuilder {
+	public create(entity: Model.Entity, primary: Input.PrimaryValue): UpdateBuilder {
 		return new UpdateBuilder(
 			this.schema,
 			entity,
 			this.whereBuilder,
-			uniqueWhere,
+			primary,
 			this.pathFactory,
 			this.predicateFactory,
 		)

package/src/mapper/update/Updater.ts

@@ -4,8 +4,7 @@ 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 { acceptEveryFieldVisitor, SchemaDatabaseMetadata } from '@contember/schema-utils'
 import {
 	collectResults,
 	MutationNoResultError,
@@ -22,6 +21,7 @@ import { rowDataToFieldValues } from '../ColumnValue'
 export class Updater {
 	constructor(
 		private readonly schema: Model.Schema,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 		private readonly predicateFactory: PredicateFactory,
 		private readonly updateBuilderFactory: UpdateBuilderFactory,
 	) {}
@@ -33,9 +33,7 @@ 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)
 		updateBuilder.addPredicates(predicateFields)
@@ -48,12 +46,12 @@ 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)
+		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)
+			return await collectResults(this.schema, this.schemaDatabaseMetadata, mutationResultPromise, otherPromises)
 		}
 	}
 
@@ -63,22 +61,20 @@ export class Updater {
 		primaryValue: Input.PrimaryValue,
 		builderCb: (builder: UpdateBuilder) => void,
 	): Promise<MutationResultList> {
-		const updateBuilder = this.updateBuilderFactory.create(entity, {
-			[entity.primary]: { eq: primaryValue },
-		})
+		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)
+		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)]
 		}

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,13 +16,14 @@ 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'
 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'>>
 
@@ -29,11 +32,10 @@ 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,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 	) {}
 
 	public async resolveTransaction(info: GraphQLResolveInfo, options: TransactionOptions): Promise<Result.TransactionResult> {
@@ -60,7 +62,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()
@@ -196,7 +198,7 @@ export class MutationResolver {
 			}
 			if (options?.deferForeignKeyConstraints) {
 				logger.debug('MutationResolver: validating fk constraints')
-				const constraintsResult = await tryMutation(this.schema, async () => {
+				const constraintsResult = await tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 					await mapper.constraintHelper.setFkConstraintsImmediate()
 					return []
 				})
@@ -468,25 +470,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/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/tsconfig.json

@@ -5,26 +5,12 @@
 		"esModuleInterop": true
 	},
 	"references": [
-		{
-			"path": "../../database/src"
-		},
-		{
-			"path": "../../dic/src"
-		},
-		{
-			"path": "../../graphql-utils/src"
-		},
-		{
-			"path": "../../logger/src"
-		},
-		{
-			"path": "../../schema/src"
-		},
-		{
-			"path": "../../schema-definition/src"
-		},
-		{
-			"path": "../../schema-utils/src"
-		}
+		{ "path": "../../database/src" },
+		{ "path": "../../dic/src" },
+		{ "path": "../../graphql-utils/src" },
+		{ "path": "../../logger/src" },
+		{ "path": "../../schema/src" },
+		{ "path": "../../schema-definition/src" },
+		{ "path": "../../schema-utils/src" }
 	]
 }

package/src/types.ts

@@ -1,11 +1,10 @@
 import { Acl } from '@contember/schema'
 import { Client } from '@contember/database'
-import { Container } from '@contember/dic'
-import { ExecutionContainer } from './resolvers'
+import { ExecutionContainer } from './ExecutionContainer'
 
 export interface Context {
 	db: Client
 	identityVariables: Acl.VariablesMap
-	executionContainer: Container<ExecutionContainer>
-	timer: <T>(event: string, cb?: () => T) => Promise<T>
+	executionContainer: ExecutionContainer
+	timer: <T>(event: string, cb: () => T) => T
 }

package/src/utils/index.ts

@@ -1,5 +1,4 @@
 export * from './accessor'
-export * from './arrays'
 export * from './assertNever'
 export * from './Interface'
 export * from './isIt'

package/src/utils/uniqueWhereFields.ts

@@ -15,5 +15,5 @@ export const getFieldsForUniqueWhere = (schema: Model.Schema, entity: Model.Enti
 		}),
 	).filter((it): it is [string] => !!it)
 
-	return [[entity.primary], ...Object.values(entity.unique).map(it => it.fields), ...relations]
+	return [[entity.primary], ...entity.unique.map(it => it.fields), ...relations]
 }