@contember/engine-content-api 2.1.0-alpha.30 → 2.1.0-alpha.36

package/src/mapper/update/UpdateBuilder.ts

@@ -57,93 +57,89 @@ export class UpdateBuilder {
 	}
 
 	public async execute(mapper: Mapper): Promise<UpdateResult> {
-		try {
-			const resolvedData = [...this.rowData.values()]
-			if (Object.keys(resolvedData).length === 0) {
-				return { values: [], affectedRows: null, executed: false }
-			}
-			const oldColSuffix = '_old__'
-
-			const qb = DbUpdateBuilder.create()
-				.with('newData_', qb => {
-					qb = resolvedData.reduce(
-						(qb, value) =>
-							qb
-								.select(
-									expr => expr.selectValue(
+		const resolvedData = [...this.rowData.values()]
+		if (Object.keys(resolvedData).length === 0) {
+			return { values: [], affectedRows: null, executed: false }
+		}
+		const oldColSuffix = '_old__'
+
+		const qb = DbUpdateBuilder.create()
+			.with('newData_', qb => {
+				qb = resolvedData.reduce(
+					(qb, value) =>
+						qb
+							.select(
+								expr =>
+									expr.selectValue(
 										normalizeDbValue(value.value, value.columnType),
 										value.columnType,
 									),
-									value.columnName,
-								)
-								.select(['root_', value.columnName], value.columnName + oldColSuffix),
-						qb,
-					)
-					const columns = new Set(resolvedData.map(it => it.columnName))
-					const allColumns: string[] = Object.values(
-						acceptEveryFieldVisitor(this.schema, this.entity, {
-							visitColumn: ({ column }) => column.columnName,
-							visitManyHasOne: ({ relation }) => relation.joiningColumn.columnName,
-							visitOneHasOneOwning: ({ relation }) => relation.joiningColumn.columnName,
-							visitManyHasManyInverse: () => null,
-							visitManyHasManyOwning: () => null,
-							visitOneHasOneInverse: () => null,
-							visitOneHasMany: () => null,
-						}),
-					).filter((it): it is string => it !== null)
-
-					const remainingColumns = allColumns.filter(it => !columns.has(it))
-					qb = qb.from(this.entity.tableName, 'root_')
-
-					qb = remainingColumns.reduce((qb, columnName) => qb.select(['root_', columnName]), qb)
-
-					qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([]), {
-						and: [{
-							[this.entity.primary]: { eq: this.primary },
-						}, this.oldWhere],
-					})
-
-					return qb
-				})
-				.table(this.entity.tableName)
-				.values(
-					resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
-						(result: object, item) => ({
-							...result,
-							[item.columnName]: expr => expr.select(['newData_', item.columnName]),
-						}),
-						{},
-					),
+								value.columnName,
+							)
+							.select(['root_', value.columnName], value.columnName + oldColSuffix),
+					qb,
 				)
-				.returning(...resolvedData.map(it => it.columnName + oldColSuffix))
-				.from(qb => {
-					qb = qb.from('newData_')
-					const col1 = tuple(this.entity.tableName, this.entity.primaryColumn)
-					const col2 = tuple('newData_', this.entity.primaryColumn)
-					qb = qb.where(expr => expr.compareColumns(col1, Operator.eq, col2))
-					qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([], 'newData_'), this.newWhere)
-					return qb
+				const columns = new Set(resolvedData.map(it => it.columnName))
+				const allColumns: string[] = Object.values(
+					acceptEveryFieldVisitor(this.schema, this.entity, {
+						visitColumn: ({ column }) => column.columnName,
+						visitManyHasOne: ({ relation }) => relation.joiningColumn.columnName,
+						visitOneHasOneOwning: ({ relation }) => relation.joiningColumn.columnName,
+						visitManyHasManyInverse: () => null,
+						visitManyHasManyOwning: () => null,
+						visitOneHasOneInverse: () => null,
+						visitOneHasMany: () => null,
+					}),
+				).filter((it): it is string => it !== null)
+
+				const remainingColumns = allColumns.filter(it => !columns.has(it))
+				qb = qb.from(this.entity.tableName, 'root_')
+
+				qb = remainingColumns.reduce((qb, columnName) => qb.select(['root_', columnName]), qb)
+
+				qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([]), {
+					and: [{
+						[this.entity.primary]: { eq: this.primary },
+					}, this.oldWhere],
 				})
 
-
-			const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData, this.primary)
-			await mapper.eventManager.fire(beforeEvent)
-
-			const result = await qb.execute(mapper.db)
-
-			if (result.length === 1) {
-				const eventData = (resolvedData).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, affectedRows: result.length, executed: true }
-		} catch (e) {
-			throw e
+				return qb
+			})
+			.table(this.entity.tableName)
+			.values(
+				resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
+					(result: object, item) => ({
+						...result,
+						[item.columnName]: expr => expr.select(['newData_', item.columnName]),
+					}),
+					{},
+				),
+			)
+			.returning(...resolvedData.map(it => it.columnName + oldColSuffix))
+			.from(qb => {
+				qb = qb.from('newData_')
+				const col1 = tuple(this.entity.tableName, this.entity.primaryColumn)
+				const col2 = tuple('newData_', this.entity.primaryColumn)
+				qb = qb.where(expr => expr.compareColumns(col1, Operator.eq, col2))
+				qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([], 'newData_'), this.newWhere)
+				return qb
+			})
+
+		const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData, this.primary)
+		await mapper.eventManager.fire(beforeEvent)
+
+		const result = await qb.execute(mapper.db)
+
+		if (result.length === 1) {
+			const eventData = resolvedData.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, affectedRows: result.length, executed: true }
 	}
 }

package/src/mapper/update/Updater.ts

@@ -4,7 +4,14 @@ import { Input, Model } from '@contember/schema'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
 import { acceptFieldVisitor } from '@contember/schema-utils'
-import { MutationEntryNotFoundError, MutationNoResultError, MutationNothingToDo, MutationResultList, MutationUpdateOk, NothingToDoReason } from '../Result'
+import {
+	MutationEntryNotFoundError,
+	MutationNoResultError,
+	MutationNothingToDo,
+	MutationResultList,
+	MutationUpdateOk,
+	NothingToDoReason,
+} from '../Result'
 import { UpdateBuilder } from './UpdateBuilder'
 import { rowDataToFieldValues } from '../ColumnValue'
 import { MapperInput } from '../types'

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

@@ -16,8 +16,7 @@ import { MapperInput } from '../../types'
 
 type Context = Model.ManyHasOneContext
 
-export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
-
+export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult> {
 	constructor(
 		private readonly mapper: Mapper,
 		private readonly builder: UpdateBuilder,
@@ -93,8 +92,7 @@ export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasO
 			return insertResult
 		}
 
-		return async () =>
-			await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), update)
+		return async () => await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), update)
 	}
 
 	public async disconnect(

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

@@ -8,7 +8,7 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasManyContext
 
-export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult> {
 	constructor(
 		private readonly mapper: Mapper,
 	) {
@@ -75,7 +75,7 @@ export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasM
 				{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
 				{
 					...update,
-				// [targetRelation.name]: {connect: thisPrimary}
+					// [targetRelation.name]: {connect: thisPrimary}
 				},
 			)
 			if (result[0].result === MutationResultType.notFoundError) {

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

@@ -15,14 +15,16 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneInverseContext
 
-export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+export class OneHasOneInverseUpdateInputProcessor
+	implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>
+{
 	constructor(
 		private readonly primaryValue: Input.PrimaryValue,
 		private readonly mapper: Mapper,
 	) {
 	}
 
-	public async connect({ input, ...ctx  }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere | CheckedPrimary }) {
+	public async connect({ input, ...ctx }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere | CheckedPrimary }) {
 		return async () => {
 			const [newOwner, err] = await this.mapper.getPrimaryValue(ctx.targetEntity, input)
 			if (err) return [err]
@@ -42,7 +44,6 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 		}
 	}
 
-
 	public async create(ctx: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput }) {
 		return async () => {
 			return await this.createInternal(ctx)
@@ -156,7 +157,9 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 		return result
 	}
 
-	private async createInternal({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput }) {
+	private async createInternal(
+		{ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput },
+	) {
 		const [currentOwner] = await this.mapper.getPrimaryValue(targetEntity, {
 			[targetRelation.name]: { [entity.primary]: this.primaryValue },
 		})

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

@@ -18,7 +18,9 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneOwningContext
 
-export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+export class OneHasOneOwningUpdateInputProcessor
+	implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>
+{
 	constructor(
 		private readonly primaryValue: Input.PrimaryValue,
 		private readonly mapper: Mapper,
@@ -32,7 +34,8 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		if (err) return [err]
 		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
 		const currentOwnerResult = await this.handleStateBeforeConnect(context, currentInverseSide, newInverseSide)
-		if (currentOwnerResult.some(it => it.error)
+		if (
+			currentOwnerResult.some(it => it.error)
 			|| (currentOwnerResult.length === 1 && currentOwnerResult[0].result === MutationResultType.nothingToDo)
 		) {
 			return currentOwnerResult
@@ -66,14 +69,17 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		}
 	}
 
-	public async connectOrCreate({ input: { connect, create }, ...context }: Model.OneHasOneOwningContext & { input: MapperInput.ConnectOrCreateInput }) {
+	public async connectOrCreate(
+		{ input: { connect, create }, ...context }: Model.OneHasOneOwningContext & { input: MapperInput.ConnectOrCreateInput },
+	) {
 		const { relation, targetRelation, targetEntity, entity } = context
 		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
 		const [newInverseSide] = await this.mapper.getPrimaryValue(targetEntity, connect)
 
 		if (newInverseSide) {
 			const currentOwnerResult = await this.handleStateBeforeConnect(context, currentInverseSide, newInverseSide)
-			if (currentOwnerResult.some(it => it.error)
+			if (
+				currentOwnerResult.some(it => it.error)
 				|| (currentOwnerResult.length === 1 && currentOwnerResult[0].result === MutationResultType.nothingToDo)
 			) {
 				return currentOwnerResult
@@ -85,7 +91,6 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 					...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
 				]
 			}
-
 		}
 
 		const createResult = await this.createInternal({ ...context, input: create }, currentInverseSide)
@@ -116,7 +121,9 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		}
 	}
 
-	public async upsert({ entity, relation, targetEntity, input: { create, update } }: Model.OneHasOneOwningContext & { input: UpdateInputProcessor.UpsertInput }) {
+	public async upsert(
+		{ entity, relation, targetEntity, input: { create, update } }: Model.OneHasOneOwningContext & { input: UpdateInputProcessor.UpsertInput },
+	) {
 		const primary = await this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
 		if (!primary) {
 			const insertResult = await this.mapper.insert(targetEntity, create)
@@ -184,14 +191,22 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		return await this.mapper.insert(targetEntity, input)
 	}
 
-	private async getCurrentInverseSide(targetRelation: Model.OneHasOneInverseRelation | null, relation: Model.OneHasOneOwningRelation, entity: Model.Entity) {
+	private async getCurrentInverseSide(
+		targetRelation: Model.OneHasOneInverseRelation | null,
+		relation: Model.OneHasOneOwningRelation,
+		entity: Model.Entity,
+	) {
 		if ((targetRelation && !targetRelation.nullable) || relation.orphanRemoval) {
 			return this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
 		}
 		return undefined
 	}
 
-	private async cleanupOrphan(relation: Model.OneHasOneOwningRelation, targetEntity: Model.Entity, currentInverseSide: Input.PrimaryValue | undefined) {
+	private async cleanupOrphan(
+		relation: Model.OneHasOneOwningRelation,
+		targetEntity: Model.Entity,
+		currentInverseSide: Input.PrimaryValue | undefined,
+	) {
 		if (relation.orphanRemoval && currentInverseSide) {
 			return await this.mapper.delete(targetEntity, { [targetEntity.primary]: currentInverseSide })
 		}
@@ -203,7 +218,6 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		currentInverseSide: Input.PrimaryValue | undefined,
 		newInverseSide: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-
 		if (currentInverseSide === newInverseSide) {
 			return [new MutationNothingToDo([], NothingToDoReason.alreadyExists)]
 		}

package/src/resolvers/GraphQlQueryAstFactory.ts

@@ -21,7 +21,6 @@ type NodeFilter = (node: GraphQlFieldNode, path: string[]) => boolean
 type AnyNode = ObjectNode | FieldNode
 
 export class GraphQlQueryAstFactory {
-
 	public create<Args = any>(info: GraphQLResolveInfo, filter?: NodeFilter): ObjectNode<Args> {
 		const node = ResolveInfoUtils.extractFieldNode(info)
 		const parentType = info.parentType

package/src/resolvers/MutationResolver.ts

@@ -44,11 +44,11 @@ export class MutationResolver {
 	public async resolveTransaction(info: GraphQLResolveInfo, options: TransactionOptions): Promise<Result.TransactionResult> {
 		const queryAst = this.graphqlQueryAstFactory.create(info, (node, path) => {
 			return (
-				(path.length === 1 && !['ok', 'validation', 'errorMessage', 'errors'].includes(node.name.value)) ||
-				(path.length === 2 && node.name.value === 'node') ||
-				path.length > 2 ||
-				path.length === 0 ||
-				(path.length > 1 && path[1] === 'query')
+				(path.length === 1 && !['ok', 'validation', 'errorMessage', 'errors'].includes(node.name.value))
+				|| (path.length === 2 && node.name.value === 'node')
+				|| path.length > 2
+				|| path.length === 0
+				|| (path.length > 1 && path[1] === 'query')
 			)
 		})
 		const fields = GraphQlQueryAstFactory.resolveObjectType(info.returnType).getFields()
@@ -189,7 +189,7 @@ export class MutationResolver {
 							? {
 								valid: result.validation.valid,
 								errors: validationErrors,
-							  }
+							}
 							: { valid: true, errors: [] },
 						errorMessage: [
 							this.stringifyValidationErrors(validationErrors),
@@ -429,8 +429,8 @@ export class MutationResolver {
 
 		const result = await mapper.delete(entity, queryAst.args.by, queryAst.args.filter)
 		if (
-			result.length >= 1 &&
-			(result[0].result === MutationResultType.ok || result[0].result === MutationResultType.nothingToDo)
+			result.length >= 1
+			&& (result[0].result === MutationResultType.ok || result[0].result === MutationResultType.nothingToDo)
 		) {
 			return { ok: true, errors: [], ...nodes }
 		} else {
@@ -492,7 +492,6 @@ export class MutationResolver {
 							}
 							return { ...result, ...errorResponse }
 						}
-
 					}
 					return result
 				})
@@ -504,7 +503,6 @@ export class MutationResolver {
 				maxTimeout: 1000,
 			},
 		)
-
 	}
 
 	private createErrorResponse(result: MutationResultList) {
@@ -545,7 +543,7 @@ export class MutationResolver {
 				path.map(it => ({
 					...it,
 					__typename: 'field' in it ? '_FieldPathFragment' : '_IndexPathFragment',
-				})),
+				}))
 			)
 			const path = paths[0] || []
 			switch (it.result) {
@@ -594,8 +592,8 @@ export class MutationResolver {
 			return undefined
 		}
 		return (
-			'Validation has failed:\n' +
-			validationErrors.map(it => `${this.stringifyPath(it.path)}: ${it.message.text}`).join('\n')
+			'Validation has failed:\n'
+			+ validationErrors.map(it => `${this.stringifyPath(it.path)}: ${it.message.text}`).join('\n')
 		)
 	}
 
@@ -604,8 +602,8 @@ export class MutationResolver {
 			return undefined
 		}
 		return (
-			'Execution has failed:\n' +
-			executionErrors.map(it => `${this.stringifyPath(it.paths[0] || [])}: ${it.type} (${it.message || ''})`)
+			'Execution has failed:\n'
+			+ executionErrors.map(it => `${this.stringifyPath(it.paths[0] || [])}: ${it.type} (${it.message || ''})`)
 		)
 	}
 

package/src/schema/ColumnTypeResolver.ts

@@ -93,7 +93,7 @@ export class ColumnTypeResolver {
 			case Model.ColumnType.Json:
 				return this.customTypeProvider.jsonType
 			default:
-				(({}: never): never => {
+				;(({}: never): never => {
 					throw new ImplementationException('Invalid column type')
 				})(type)
 		}

package/src/schema/ConditionTypeProvider.ts

@@ -75,7 +75,6 @@ export class ConditionTypeProvider {
 					}
 				}
 
-
 				return conditions
 			},
 		})

package/src/schema/CustomTypesProvider.ts

@@ -20,11 +20,10 @@ function validateTime(value: unknown): string {
 	return `${hours}:${minutes}:${seconds}${fraction}`
 }
 
-
 export class CustomTypesProvider {
 	public readonly uuidType: GraphQLScalarType = UuidType
 
-	//todo: implement serialize, parseValue and parseLiteral properly
+	// todo: implement serialize, parseValue and parseLiteral properly
 
 	public readonly dateType: GraphQLScalarType = new GraphQLScalarType({
 		name: 'Date',

package/src/schema/EntityTypeProvider.ts

@@ -77,9 +77,7 @@ 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.values(entity.fields).filter(field =>
-			acceptFieldVisitor(this.schema, entity, field.name, accessVisitor),
-		)
+		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] = {

package/src/schema/GraphQlSchemaBuilder.ts

@@ -63,9 +63,7 @@ export class GraphQlSchemaBuilder {
 			queries.set('transaction', {
 				type: queryTransactionType,
 				resolve: async (parent, args, context: Context, info) => {
-					return context.timer(`GraphQL.query.${info.fieldName}`, () =>
-						context.executionContainer.readResolver.resolveTransaction(info),
-					)
+					return context.timer(`GraphQL.query.${info.fieldName}`, () => context.executionContainer.readResolver.resolveTransaction(info))
 				},
 			})
 		}
@@ -105,13 +103,17 @@ export class GraphQlSchemaBuilder {
 				type: new GraphQLNonNull(
 					mutationTransactionType,
 				),
-				resolve: async (parent, args: { options?: { deferForeignKeyConstraints?: boolean; deferUniqueConstraints?: 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,
-						}),
-					)
+						}))
 				},
 			})
 			mutations.set('query', {
@@ -138,7 +140,6 @@ export class GraphQlSchemaBuilder {
 			}),
 		})
 
-
 		return {
 			query: queryObjectType,
 			types: args.types,