@contember/engine-content-api 2.0.0-alpha.20 → 2.0.0-alpha.21

package/src/mapper/update/UpdateBuilder.ts

@@ -1,28 +1,21 @@
 import { tuple } from '../../utils'
 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 { Operator, QueryBuilder, UpdateBuilder as DbUpdateBuilder, Value as DbValue } from '@contember/database'
 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 { AfterUpdateEvent, BeforeUpdateEvent } from '../EventManager'
 import { Mapper } from '../Mapper'
 
 export interface UpdateResult {
 	values: ResolvedColumnValue[]
 	executed: boolean
-	aborted: boolean
 	affectedRows: number | null
 }
 
-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: Map<string, ColumnValue<AbortDataManipulation>> = new Map()
+export class UpdateBuilder {
+	private rowData: Map<string, ColumnValue> = new Map()
 
 	private newWhere: { and: Input.OptionalWhere[] } = { and: [] }
 	private oldWhere: { and: Input.OptionalWhere[] } = { and: [] }
@@ -38,8 +31,8 @@ export class UpdateBuilder implements DataManipulationBuilder {
 
 	public addFieldValue(
 		fieldName: string,
-		value: Value.GenericValueLike<Value.AtomicValue<AbortDataManipulation | undefined>>,
-	): Promise<Value.AtomicValue<AbortDataManipulation | undefined>> {
+		value: Value.GenericValueLike<Value.AtomicValue<undefined>>,
+	): Promise<Value.AtomicValue<undefined>> {
 		const columnName = getColumnName(this.schema, this.entity, fieldName)
 		const columnType = getColumnType(this.schema, this.entity, fieldName)
 		const resolvedValue = resolveGenericValue(value)
@@ -63,14 +56,9 @@ export class UpdateBuilder implements DataManipulationBuilder {
 
 	public async execute(mapper: Mapper): Promise<UpdateResult> {
 		try {
-			const resolvedData = await resolveRowData<AbortDataManipulation>([...this.rowData.values()])
+			const resolvedData = await resolveRowData([...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 === AbortDataManipulation)) {
-				this.resolver(null)
-				return { values: [], affectedRows: null, executed: false, aborted: true }
+				return { values: [], affectedRows: null, executed: false }
 			}
 			const oldColSuffix = '_old__'
 
@@ -134,7 +122,6 @@ export class UpdateBuilder implements DataManipulationBuilder {
 			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 => ({
@@ -146,9 +133,8 @@ export class UpdateBuilder implements DataManipulationBuilder {
 				await mapper.eventManager.fire(afterUpdateEvent)
 			}
 
-			return { values: resolvedData as ResolvedColumnValue[], affectedRows: result.length, executed: true, aborted: false }
+			return { values: resolvedData as ResolvedColumnValue[], affectedRows: result.length, executed: true }
 		} catch (e) {
-			this.resolver(null)
 			throw e
 		}
 	}

package/src/mapper/update/Updater.ts

@@ -1,20 +1,11 @@
-import { SqlUpdateInputProcessor } from './SqlUpdateInputProcessor'
+import { SqlUpdateInputProcessor, SqlUpdateInputProcessorResult } from './SqlUpdateInputProcessor'
 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 {
-	collectResults,
-	MutationNoResultError,
-	MutationNothingToDo,
-	MutationResultList,
-	MutationUpdateOk,
-	NothingToDoReason,
-	ResultListNotFlatten,
-	RowValues,
-} from '../Result'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { MutationNoResultError, MutationNothingToDo, MutationResultList, MutationUpdateOk, NothingToDoReason, RowValues } from '../Result'
 import { UpdateBuilder } from './UpdateBuilder'
 import { rowDataToFieldValues } from '../ColumnValue'
 import { DatabaseMetadata } from '@contember/database'
@@ -42,18 +33,57 @@ export class Updater {
 			updateBuilder.addOldWhere(filter)
 		}
 
-		const updateVisitor = new SqlUpdateInputProcessor(primaryValue, data, updateBuilder, mapper)
-		const visitor = new UpdateInputVisitor<MutationResultList>(updateVisitor, this.schema, data)
-		const promises = acceptEveryFieldVisitor<Promise<ResultListNotFlatten | undefined>>(this.schema, entity, visitor)
+		const visitor = new UpdateInputVisitor<SqlUpdateInputProcessorResult>(
+			new SqlUpdateInputProcessor(primaryValue, data, updateBuilder, mapper),
+			this.schema,
+			data,
+		)
+		const resultList: MutationResultList = []
+		const postUpdates: Exclude<SqlUpdateInputProcessorResult, MutationResultList>[] = []
 
-		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, data, values)
-		const mutationResultPromise = Updater.executeUpdate(updateBuilder, mapper, okResultFactory)
-		const otherPromises = Object.values(promises)
-		if (otherPromises.length === 0) {
-			return await mutationResultPromise
+		for (const key of Object.keys(data)) {
+			const resultSet = await acceptFieldVisitor(
+				this.schema,
+				entity,
+				key,
+				visitor,
+			)
+			for (const result of resultSet) {
+				if (typeof result === 'function') {
+					postUpdates.push(result)
+				} else {
+					for (const resultItem of await result) {
+						resultList.push(resultItem)
+						if (resultItem.error) {
+							return resultList
+						}
+					}
+				}
+			}
+		}
+
+		const result = await updateBuilder.execute(mapper)
+
+		if (!result.executed) {
+			resultList.unshift(new MutationNothingToDo([], NothingToDoReason.noData))
+		} else if (result.affectedRows !== 1) {
+			return [new MutationNoResultError([])]
 		} else {
-			return await collectResults(this.schema, this.schemaDatabaseMetadata, mutationResultPromise, otherPromises)
+			const okResult = new MutationUpdateOk([], entity, primaryValue, data, rowDataToFieldValues(result.values))
+			resultList.unshift(okResult)
+		}
+
+		for (const postUpdate of postUpdates) {
+			const postInsertResult = await postUpdate({ primary: primaryValue })
+			for (const result of postInsertResult) {
+				resultList.push(result)
+				if (result.error) {
+					return resultList
+				}
+			}
 		}
+
+		return resultList
 	}
 
 	public async updateCb(
@@ -64,27 +94,16 @@ export class Updater {
 	): Promise<MutationResultList> {
 		const updateBuilder = this.updateBuilderFactory.create(entity, primaryValue)
 
-		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, {}, values)
 		builderCb(updateBuilder)
 
-		return Updater.executeUpdate(updateBuilder, mapper, okResultFactory)
-	}
-
-	private static async executeUpdate(
-		updateBuilder: UpdateBuilder,
-		mapper: Mapper,
-		okResultFactory: (values: RowValues) => MutationUpdateOk,
-	): Promise<MutationResultList> {
 		const result = await updateBuilder.execute(mapper)
-		if (result.aborted) {
-			return [new MutationNothingToDo([], NothingToDoReason.aborted)]
-		}
+
 		if (!result.executed) {
 			return [new MutationNothingToDo([], NothingToDoReason.noData)]
 		}
 		if (result.affectedRows !== 1) {
 			return [new MutationNoResultError([])]
 		}
-		return [okResultFactory(rowDataToFieldValues(result.values))]
+		return [new MutationUpdateOk([], entity, primaryValue, {}, rowDataToFieldValues(result.values))]
 	}
 }

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

@@ -0,0 +1,116 @@
+import { UpdateInputProcessor } from '../../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import { getInsertPrimary, MutationEntryNotFoundError } from '../../Result'
+import { Mapper } from '../../Mapper'
+import { SqlUpdateInputProcessorResult } from '../../update'
+
+type Context = Model.ManyHasManyOwningContext | Model.ManyHasManyInverseContext
+
+export class ManyHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult> {
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (!otherPrimary) {
+				return [new MutationEntryNotFoundError([], input)]
+			}
+			return await this.mapper.connectJunction(entity, relation, primary, otherPrimary)
+		}
+	}
+
+	public async create(
+		{ entity, targetEntity, relation, input }: Context & { input: Input.CreateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const insertResult = await this.mapper.insert(targetEntity, input)
+			const insertPrimary = getInsertPrimary(insertResult)
+			if (!insertPrimary) {
+				return insertResult
+			}
+			return [
+				...insertResult,
+				...(await this.mapper.connectJunction(entity, relation, primary, insertPrimary)),
+			]
+		}
+	}
+
+	public async connectOrCreate(
+		context: Context & { input: Input.ConnectOrCreateInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			let otherPrimary = await this.mapper.getPrimaryValue(context.targetEntity, context.input.connect)
+			if (!otherPrimary) {
+				const insertResult = await this.mapper.insert(context.targetEntity, context.input.create)
+				otherPrimary = getInsertPrimary(insertResult)
+				if (!otherPrimary) {
+					return insertResult
+				}
+			}
+			return await this.mapper.connectJunction(context.entity, context.relation, primary, otherPrimary)
+		}
+	}
+
+	public async update(
+		{ entity, targetEntity, relation, input: { where, data } }: Context & { input: UpdateInputProcessor.UpdateManyInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, where)
+			if (!otherPrimary) {
+				return [new MutationEntryNotFoundError([], where)]
+			}
+			return [
+				...(await this.mapper.update(targetEntity, { [targetEntity.primary]: otherPrimary }, data)),
+				...(await this.mapper.connectJunction(entity, relation, primary, otherPrimary)),
+			]
+		}
+	}
+
+	public async upsert(
+		{ entity, relation, targetEntity, input: { create, update, where } }: Context & { input: UpdateInputProcessor.UpsertManyInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, where)
+			if (otherPrimary) {
+				const updateResult = await this.mapper.update(targetEntity, { [targetEntity.primary]: otherPrimary }, update)
+				const connectResult = await this.mapper.connectJunction(entity, relation, primary, otherPrimary)
+				return [...updateResult, ...connectResult]
+			} else {
+				const insertResult = await this.mapper.insert(targetEntity, create)
+
+				const primaryValue = getInsertPrimary(insertResult)
+				if (!primaryValue) {
+					return insertResult
+				}
+				const connectResult = await this.mapper.connectJunction(entity, relation, primary, primaryValue)
+				return [...insertResult, ...connectResult]
+			}
+		}
+	}
+
+	public async disconnect(
+		{ entity, targetEntity, relation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (!otherPrimary) {
+				return [new MutationEntryNotFoundError([], input)]
+			}
+
+			return await this.mapper.disconnectJunction(entity, relation, primary, otherPrimary)
+		}
+	}
+
+	public async delete(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.delete(targetEntity, input)
+		}
+	}
+}

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

@@ -0,0 +1,125 @@
+import { UpdateInputProcessor } from '../../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import {
+	ConstraintType,
+	getInsertPrimary,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationNothingToDo,
+	NothingToDoReason,
+} from '../../Result'
+import { Mapper } from '../../Mapper'
+import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
+import { UpdateBuilder } from '../UpdateBuilder'
+
+type Context = Model.ManyHasOneContext
+
+export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+
+	constructor(
+		private readonly mapper: Mapper,
+		private readonly builder: UpdateBuilder,
+		private readonly primary: Input.PrimaryValue,
+	) {
+	}
+
+	public async connect(
+		{ targetEntity, relation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		const value = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (!value) {
+			return [new MutationEntryNotFoundError([], input)]
+		}
+		this.builder.addFieldValue(relation.name, value)
+		return []
+	}
+
+	public async create(
+		{ relation, targetEntity, input }: Context & { input: Input.CreateDataInput },
+	) {
+		const insertResult = await this.mapper.insert(targetEntity, input)
+		const value = getInsertPrimary(insertResult)
+		if (!value) {
+			return insertResult
+		}
+		this.builder.addFieldValue(relation.name, value)
+		return []
+	}
+
+	public async connectOrCreate(
+		{ input: { connect, create }, relation, targetEntity }: Context & { input: Input.ConnectOrCreateInput },
+	) {
+		const value = await this.mapper.getPrimaryValue(targetEntity, connect)
+		if (value) {
+			this.builder.addFieldValue(relation.name, value)
+		} else {
+			const insertResult = await this.mapper.insert(targetEntity, create)
+			const primary = getInsertPrimary(insertResult)
+			if (!primary) {
+				return insertResult
+			}
+
+			this.builder.addFieldValue(relation.name, primary)
+		}
+		return []
+	}
+
+	public async update(
+		{ entity, relation, targetEntity, targetRelation, input }: Context & { input: Input.UpdateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const inversePrimary = await this.mapper.selectField(
+				entity,
+				{ [entity.primary]: primary },
+				relation.name,
+			)
+			if (!inversePrimary) {
+				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+			}
+			return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, input)
+		}
+	}
+
+	public async upsert(
+		{ entity, relation, targetEntity, input: { create, update } }: Context & { input: UpdateInputProcessor.UpsertInput },
+	) {
+		const inversePrimary = await this.mapper.selectField(entity, { [entity.primary]: this.primary }, relation.name)
+		if (!inversePrimary) {
+			const insertResult = await this.mapper.insert(targetEntity, create)
+			const insertPrimary = getInsertPrimary(insertResult)
+			if (insertPrimary) {
+				this.builder.addFieldValue(relation.name, insertPrimary)
+			}
+			return insertResult
+		}
+
+		return async () =>
+			await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, update)
+	}
+
+	public async disconnect(
+		{ entity, targetEntity, relation, targetRelation }: Context & { input: undefined },
+	) {
+		if (!relation.nullable) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		this.builder.addFieldValue(relation.name, null)
+		return []
+	}
+
+	public async delete(
+		{ entity, targetEntity, relation, targetRelation }: Context & { input: undefined },
+	) {
+		if (!relation.nullable && relation.joiningColumn.onDelete !== Model.OnDelete.cascade) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const inversePrimary = await this.mapper.selectField(
+				entity,
+				{ [entity.primary]: primary },
+				relation.name,
+			)
+			return await this.mapper.delete(targetEntity, { [targetEntity.primary]: inversePrimary })
+		}
+	}
+}

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

@@ -0,0 +1,111 @@
+import { UpdateInputProcessor } from '../../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import { Mapper } from '../../Mapper'
+import { MutationResultType } from '../../Result'
+import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
+
+type Context = Model.OneHasManyContext
+
+export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(
+		{ entity, targetEntity, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.update(targetEntity, input, {
+				[targetRelation.name]: { connect: { [entity.primary]: primary } },
+			})
+		}
+	}
+
+	public async create(
+		{ entity, targetEntity, targetRelation, input }: Context & { input: Input.CreateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.insert(targetEntity, {
+				...input,
+				[targetRelation.name]: { connect: { [entity.primary]: primary } },
+			})
+		}
+	}
+
+	public async connectOrCreate(
+		{ entity, targetRelation, targetEntity, input: { connect, create } }: Context & { input: Input.ConnectOrCreateInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const connectData = {
+				[targetRelation.name]: {
+					connect: { [entity.primary]: primary },
+				},
+			}
+			return await this.mapper.upsert(targetEntity, connect, connectData, {
+				...create,
+				...connectData,
+			})
+		}
+	}
+
+	public async update(
+		{ entity, targetEntity, targetRelation, input: { data, where } }: Context & { input: UpdateInputProcessor.UpdateManyInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.update(
+				targetEntity,
+				{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
+				{
+					...data,
+					// [targetRelation.name]: {connect: thisPrimary}
+				},
+			)
+		}
+	}
+
+	public async upsert(
+		{ entity, targetEntity, targetRelation, input: { create, update, where } }: Context & { input: UpdateInputProcessor.UpsertManyInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const result = await this.mapper.update(
+				targetEntity,
+				{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
+				{
+					...update,
+				// [targetRelation.name]: {connect: thisPrimary}
+				},
+			)
+			if (result[0].result === MutationResultType.notFoundError) {
+				return await this.mapper.insert(targetEntity, {
+					...create,
+					[targetRelation.name]: { connect: { [entity.primary]: primary } },
+				})
+			}
+			return result
+		}
+	}
+
+	public async disconnect(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.update(
+				targetEntity,
+				{ ...input, [targetRelation.name]: { [entity.primary]: primary } },
+				{ [targetRelation.name]: { disconnect: true } },
+			)
+		}
+	}
+
+	public async delete(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.delete(targetEntity, {
+				...input,
+				[targetRelation.name]: { [entity.primary]: primary },
+			})
+		}
+	}
+}