@contember/engine-content-api 2.0.0-alpha.9 → 2.0.0-beta.1

package/src/inputProcessing/UpdateInputVisitor.ts

@@ -1,31 +1,32 @@
 import { Input, Model } from '@contember/schema'
-import { filterObject, isIt } from '../utils'
+import { filterObject } from '../utils'
 import { UpdateInputProcessor } from './UpdateInputProcessor'
 import { ImplementationException, UserError } from '../exception'
+import { MapperInput } from '../mapper'
 
 export class UpdateInputVisitor<Result> implements
-	Model.ColumnVisitor<Promise<Result | Result[] | undefined>>,
-	Model.RelationByTypeVisitor<Promise<Result | Result[] | undefined>> {
+	Model.ColumnVisitor<Promise<Result[]>>,
+	Model.RelationByTypeVisitor<Promise<Result[]>> {
 
 	constructor(
 		private readonly updateInputProcessor: UpdateInputProcessor<Result>,
 		private readonly schema: Model.Schema,
-		private readonly data: Input.UpdateDataInput,
+		private readonly data: MapperInput.UpdateDataInput,
 	) {}
 
-	public visitColumn({ entity, column }: Model.ColumnContext): Promise<Result> {
-		return this.updateInputProcessor.column({
+	public async visitColumn({ entity, column }: Model.ColumnContext): Promise<Result[]> {
+		return [await this.updateInputProcessor.column({
 			entity,
 			column,
 			input: this.data[column.name] as Input.ColumnValue,
-		})
+		})]
 	}
 
 	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {
 		return this.processManyRelationInput(
 			this.updateInputProcessor.manyHasManyInverse,
 			context,
-			this.data[context.relation.name] as Input.CreateManyRelationInput,
+			this.data[context.relation.name] as MapperInput.CreateManyRelationInput,
 		)
 	}
 
@@ -33,7 +34,7 @@ export class UpdateInputVisitor<Result> implements
 		return this.processManyRelationInput(
 			this.updateInputProcessor.manyHasManyOwning,
 			context,
-			this.data[context.relation.name] as Input.CreateManyRelationInput,
+			this.data[context.relation.name] as MapperInput.CreateManyRelationInput,
 		)
 	}
 
@@ -41,7 +42,7 @@ export class UpdateInputVisitor<Result> implements
 		return this.processRelationInput(
 			this.updateInputProcessor.manyHasOne,
 			context,
-			this.data[context.relation.name] as Input.CreateOneRelationInput,
+			this.data[context.relation.name] as MapperInput.CreateOneRelationInput,
 		)
 	}
 
@@ -49,7 +50,7 @@ export class UpdateInputVisitor<Result> implements
 		return this.processManyRelationInput(
 			this.updateInputProcessor.oneHasMany,
 			context,
-			this.data[context.relation.name] as Input.CreateManyRelationInput,
+			this.data[context.relation.name] as MapperInput.CreateManyRelationInput,
 		)
 	}
 
@@ -57,7 +58,7 @@ export class UpdateInputVisitor<Result> implements
 		return this.processRelationInput(
 			this.updateInputProcessor.oneHasOneInverse,
 			context,
-			this.data[context.relation.name] as Input.CreateOneRelationInput,
+			this.data[context.relation.name] as MapperInput.CreateOneRelationInput,
 		)
 	}
 
@@ -65,40 +66,40 @@ export class UpdateInputVisitor<Result> implements
 		return this.processRelationInput(
 			this.updateInputProcessor.oneHasOneOwning,
 			context,
-			this.data[context.relation.name] as Input.CreateOneRelationInput,
+			this.data[context.relation.name] as MapperInput.CreateOneRelationInput,
 		)
 	}
 
-	private processRelationInput<Context>(
+	private async processRelationInput<Context>(
 		processor: UpdateInputProcessor.HasOneRelationInputProcessor<Context, Result>,
 		context: Context,
-		input: Input.UpdateOneRelationInput | undefined,
-	): Promise<undefined | Result> {
+		input: MapperInput.UpdateOneRelationInput | undefined,
+	): Promise< Result[]> {
 		if (input === undefined || input === null) {
-			return Promise.resolve(undefined)
+			return Promise.resolve([])
 		}
 		input = filterObject(input, (k, v) => v !== null && v !== undefined)
 		this.verifyOperations(input)
-		if (isIt<Input.ConnectRelationInput>(input, 'connect')) {
-			return processor.connect({ ...context, input: input.connect })
+		if ('connect' in input) {
+			return [await processor.connect({ ...context, input: input.connect })]
 		}
-		if (isIt<Input.CreateRelationInput>(input, 'create')) {
-			return processor.create({ ...context, input: input.create })
+		if ('create' in input) {
+			return [await processor.create({ ...context, input: input.create })]
 		}
-		if (isIt<Input.ConnectOrCreateRelationInput>(input, 'connectOrCreate')) {
-			return processor.connectOrCreate({ ...context, input: input.connectOrCreate })
+		if ('connectOrCreate' in input) {
+			return [await processor.connectOrCreate({ ...context, input: input.connectOrCreate })]
 		}
-		if (isIt<Input.DeleteRelationInput>(input, 'delete')) {
-			return processor.delete({ ...context, input: undefined })
+		if ('delete' in input) {
+			return [await processor.delete({ ...context, input: undefined })]
 		}
-		if (isIt<Input.DisconnectRelationInput>(input, 'disconnect')) {
-			return processor.disconnect({ ...context, input: undefined })
+		if ('disconnect' in input) {
+			return [await processor.disconnect({ ...context, input: undefined })]
 		}
-		if (isIt<Input.UpdateRelationInput>(input, 'update')) {
-			return processor.update({ ...context, input: input.update })
+		if ('update' in input) {
+			return [await processor.update({ ...context, input: input.update })]
 		}
-		if (isIt<Input.UpsertRelationInput>(input, 'upsert')) {
-			return processor.upsert({ ...context, input: input.upsert })
+		if ('upsert' in input) {
+			return [await processor.upsert({ ...context, input: input.upsert })]
 		}
 		throw new ImplementationException()
 	}
@@ -106,10 +107,10 @@ export class UpdateInputVisitor<Result> implements
 	private async processManyRelationInput<Context>(
 		processor: UpdateInputProcessor.HasManyRelationInputProcessor<Context, Result>,
 		context: Context,
-		input: Input.UpdateManyRelationInput | undefined,
-	): Promise<undefined | Result[]> {
+		input: MapperInput.UpdateManyRelationInput | undefined,
+	): Promise<Result[]> {
 		if (input === undefined || input === null) {
-			return Promise.resolve(undefined)
+			return Promise.resolve([])
 		}
 		const results: Array<Result> = []
 		let i = 0
@@ -118,19 +119,22 @@ export class UpdateInputVisitor<Result> implements
 			element = filterObject(element, (k, v) => v !== null && v !== undefined)
 			this.verifyOperations(element)
 			let result
-			if (isIt<Input.ConnectRelationInput>(element, 'connect')) {
+			if ('connect' in element) {
 				result = processor.connect({ ...context, input: element.connect, index: i, alias })
 			}
-			if (isIt<Input.CreateRelationInput>(element, 'create')) {
+			if ('create' in element) {
 				result = processor.create({ ...context, input: element.create, index: i, alias })
 			}
-			if (isIt<Input.DeleteSpecifiedRelationInput>(element, 'delete')) {
+			if ('connectOrCreate' in element) {
+				result = processor.connectOrCreate({ ...context, input: element.connectOrCreate, index: i, alias })
+			}
+			if ('delete' in element) {
 				result = processor.delete({ ...context, input: element.delete, index: i, alias })
 			}
-			if (isIt<Input.DisconnectSpecifiedRelationInput>(element, 'disconnect')) {
+			if ('disconnect' in element) {
 				result = processor.disconnect({ ...context, input: element.disconnect, index: i, alias })
 			}
-			if (isIt<Input.UpdateSpecifiedRelationInput>(element, 'update')) {
+			if ('update' in element) {
 				result = processor.update({
 					...context,
 					input: { where: element.update.by, data: element.update.data },
@@ -138,7 +142,7 @@ export class UpdateInputVisitor<Result> implements
 					alias,
 				})
 			}
-			if (isIt<Input.UpsertSpecifiedRelationInput>(element, 'upsert')) {
+			if ('upsert' in element) {
 				result = processor.upsert({
 					...context,
 					input: { where: element.upsert.by, update: element.upsert.update, create: element.upsert.create },

package/src/introspection/IntrospectionSchemaDefinitionFactory.ts

@@ -1,199 +1,7 @@
+import { GraphQLSchema, GraphQLSchemaConfig } from 'graphql'
 import * as ContentSchema from './content-schema.types'
 import { IntrospectionSchemaFactory } from './IntrospectionSchemaFactory'
-import { JSONType } from '@contember/graphql-utils'
-
-import {
-	GraphQLBoolean,
-	GraphQLEnumType,
-	GraphQLFieldResolver,
-	GraphQLInt,
-	GraphQLInterfaceType,
-	GraphQLList,
-	GraphQLNonNull,
-	GraphQLObjectType,
-	GraphQLSchema,
-	GraphQLSchemaConfig,
-	GraphQLString,
-	GraphQLUnionType,
-} from 'graphql'
-
-const _RuleMessage = new GraphQLObjectType({
-	name: '_RuleMessage',
-	fields: {
-		text: { type: GraphQLString },
-	},
-})
-
-const _ValidatorArgument = new GraphQLObjectType({
-	name: '_ValidatorArgument',
-	fields: {
-		validator: { type: new GraphQLNonNull(GraphQLInt) },
-	},
-})
-
-const _PathArgument = new GraphQLObjectType({
-	name: '_PathArgument',
-	fields: {
-		path: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
-	},
-})
-
-const _LiteralArgument = new GraphQLObjectType({
-	name: '_LiteralArgument',
-	fields: {
-		value: { type: JSONType },
-	},
-})
-
-const _Argument = new GraphQLUnionType({
-	name: '_Argument',
-	types: [_ValidatorArgument, _PathArgument, _LiteralArgument],
-})
-
-const _Validator = new GraphQLObjectType({
-	name: '_Validator',
-	fields: {
-		operation: { type: new GraphQLNonNull(GraphQLString) },
-		arguments: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Argument))) },
-	},
-})
-
-const _Rule = new GraphQLObjectType({
-	name: '_Rule',
-	fields: {
-		message: { type: _RuleMessage },
-		validator: { type: new GraphQLNonNull(GraphQLInt) },
-	},
-})
-
-const _FieldInterface = new GraphQLInterfaceType({
-	name: '_Field',
-	fields: {
-		name: { type: new GraphQLNonNull(GraphQLString) },
-		type: { type: new GraphQLNonNull(GraphQLString) },
-		nullable: { type: GraphQLBoolean },
-		rules: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Rule))) },
-		validators: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Validator))) },
-	},
-})
-
-const _OrderByDirection = new GraphQLEnumType({
-	name: '_OrderByDirection',
-	values: {
-		asc: {},
-		desc: {},
-	},
-})
-
-const _OrderBy = new GraphQLObjectType({
-	name: '_OrderBy',
-	fields: {
-		path: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
-		direction: { type: new GraphQLNonNull(_OrderByDirection) },
-	},
-})
-
-const _OnDeleteBehaviour = new GraphQLEnumType({
-	name: '_OnDeleteBehaviour',
-	values: {
-		restrict: {},
-		cascade: {},
-		setNull: {},
-	},
-})
-
-const _RelationSide = new GraphQLEnumType({
-	name: '_RelationSide',
-	values: {
-		owning: {},
-		inverse: {},
-	},
-})
-
-const _Relation = new GraphQLObjectType({
-	name: '_Relation',
-	interfaces: [_FieldInterface],
-	fields: {
-		name: { type: new GraphQLNonNull(GraphQLString) },
-		type: { type: new GraphQLNonNull(GraphQLString) },
-		side: { type: new GraphQLNonNull(_RelationSide) },
-		targetEntity: { type: new GraphQLNonNull(GraphQLString) },
-		ownedBy: { type: GraphQLString },
-		inversedBy: { type: GraphQLString },
-		nullable: { type: GraphQLBoolean },
-		onDelete: { type: _OnDeleteBehaviour },
-		orphanRemoval: { type: GraphQLBoolean },
-		orderBy: { type: new GraphQLList(new GraphQLNonNull(_OrderBy)) },
-		rules: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Rule))) },
-		validators: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Validator))) },
-	},
-})
-
-const _Column = new GraphQLObjectType({
-	name: '_Column',
-	interfaces: [_FieldInterface],
-	fields: {
-		name: { type: new GraphQLNonNull(GraphQLString) },
-		type: { type: new GraphQLNonNull(GraphQLString) },
-		enumName: { type: GraphQLString },
-		defaultValue: { type: JSONType },
-		nullable: { type: new GraphQLNonNull(GraphQLBoolean) },
-		rules: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Rule))) },
-		validators: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Validator))) },
-	},
-})
-
-const _UniqueConstraint = new GraphQLObjectType({
-	name: '_UniqueConstraint',
-	fields: {
-		fields: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
-	},
-})
-
-const _Entity = new GraphQLObjectType({
-	name: '_Entity',
-	fields: {
-		name: { type: new GraphQLNonNull(GraphQLString) },
-		customPrimaryAllowed: { type: new GraphQLNonNull(GraphQLBoolean) },
-		fields: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_FieldInterface))) },
-		unique: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_UniqueConstraint))) },
-	},
-})
-
-const _Enum = new GraphQLObjectType({
-	name: '_Enum',
-	fields: {
-		name: { type: new GraphQLNonNull(GraphQLString) },
-		values: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
-	},
-})
-
-const _Schema = new GraphQLObjectType({
-	name: '_Schema',
-	fields: {
-		enums: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Enum))) },
-		entities: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Entity))) },
-	},
-})
-
-
-const createSchemaConfig = (resolver?: GraphQLFieldResolver<any, any>): GraphQLSchemaConfig => {
-	return {
-		query: new GraphQLObjectType({
-			name: 'Query',
-			fields: {
-				schema: {
-					type: _Schema,
-					resolve: resolver,
-				},
-			},
-		}),
-		types: [_Column, _Relation],
-	}
-}
-
-
-export default new GraphQLSchema(createSchemaConfig())
+import { createSchemaConfig } from './introspection.schema'
 
 export class IntrospectionSchemaDefinitionFactory {
 	constructor(private readonly introspectionSchemaFactory: IntrospectionSchemaFactory) {}

package/src/introspection/index.ts

@@ -1,3 +1,4 @@
 export * as ContentSchemaTypes from './content-schema.types'
-export { IntrospectionSchemaDefinitionFactory, default as ContentSchema } from './IntrospectionSchemaDefinitionFactory'
+export { IntrospectionSchemaDefinitionFactory } from './IntrospectionSchemaDefinitionFactory'
+export { default as ContentSchema } from './introspection.schema'
 export * from './IntrospectionSchemaFactory'

package/src/introspection/introspection.schema.ts

@@ -0,0 +1,194 @@
+import { JSONType } from '@contember/graphql-utils'
+
+import {
+	GraphQLBoolean,
+	GraphQLEnumType,
+	GraphQLFieldResolver,
+	GraphQLInt,
+	GraphQLInterfaceType,
+	GraphQLList,
+	GraphQLNonNull,
+	GraphQLObjectType,
+	GraphQLSchema,
+	GraphQLSchemaConfig,
+	GraphQLString,
+	GraphQLUnionType,
+} from 'graphql'
+
+const _RuleMessage = new GraphQLObjectType({
+	name: '_RuleMessage',
+	fields: {
+		text: { type: GraphQLString },
+	},
+})
+
+const _ValidatorArgument = new GraphQLObjectType({
+	name: '_ValidatorArgument',
+	fields: {
+		validator: { type: new GraphQLNonNull(GraphQLInt) },
+	},
+})
+
+const _PathArgument = new GraphQLObjectType({
+	name: '_PathArgument',
+	fields: {
+		path: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
+	},
+})
+
+const _LiteralArgument = new GraphQLObjectType({
+	name: '_LiteralArgument',
+	fields: {
+		value: { type: JSONType },
+	},
+})
+
+const _Argument = new GraphQLUnionType({
+	name: '_Argument',
+	types: [_ValidatorArgument, _PathArgument, _LiteralArgument],
+})
+
+const _Validator = new GraphQLObjectType({
+	name: '_Validator',
+	fields: {
+		operation: { type: new GraphQLNonNull(GraphQLString) },
+		arguments: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Argument))) },
+	},
+})
+
+const _Rule = new GraphQLObjectType({
+	name: '_Rule',
+	fields: {
+		message: { type: _RuleMessage },
+		validator: { type: new GraphQLNonNull(GraphQLInt) },
+	},
+})
+
+const _FieldInterface = new GraphQLInterfaceType({
+	name: '_Field',
+	fields: {
+		name: { type: new GraphQLNonNull(GraphQLString) },
+		type: { type: new GraphQLNonNull(GraphQLString) },
+		nullable: { type: GraphQLBoolean },
+		rules: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Rule))) },
+		validators: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Validator))) },
+	},
+})
+
+const _OrderByDirection = new GraphQLEnumType({
+	name: '_OrderByDirection',
+	values: {
+		asc: {},
+		desc: {},
+	},
+})
+
+const _OrderBy = new GraphQLObjectType({
+	name: '_OrderBy',
+	fields: {
+		path: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
+		direction: { type: new GraphQLNonNull(_OrderByDirection) },
+	},
+})
+
+const _OnDeleteBehaviour = new GraphQLEnumType({
+	name: '_OnDeleteBehaviour',
+	values: {
+		restrict: {},
+		cascade: {},
+		setNull: {},
+	},
+})
+
+const _RelationSide = new GraphQLEnumType({
+	name: '_RelationSide',
+	values: {
+		owning: {},
+		inverse: {},
+	},
+})
+
+const _Relation = new GraphQLObjectType({
+	name: '_Relation',
+	interfaces: [_FieldInterface],
+	fields: {
+		name: { type: new GraphQLNonNull(GraphQLString) },
+		type: { type: new GraphQLNonNull(GraphQLString) },
+		side: { type: new GraphQLNonNull(_RelationSide) },
+		targetEntity: { type: new GraphQLNonNull(GraphQLString) },
+		ownedBy: { type: GraphQLString },
+		inversedBy: { type: GraphQLString },
+		nullable: { type: GraphQLBoolean },
+		onDelete: { type: _OnDeleteBehaviour },
+		orphanRemoval: { type: GraphQLBoolean },
+		orderBy: { type: new GraphQLList(new GraphQLNonNull(_OrderBy)) },
+		rules: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Rule))) },
+		validators: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Validator))) },
+	},
+})
+
+const _Column = new GraphQLObjectType({
+	name: '_Column',
+	interfaces: [_FieldInterface],
+	fields: {
+		name: { type: new GraphQLNonNull(GraphQLString) },
+		type: { type: new GraphQLNonNull(GraphQLString) },
+		enumName: { type: GraphQLString },
+		defaultValue: { type: JSONType },
+		nullable: { type: new GraphQLNonNull(GraphQLBoolean) },
+		rules: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Rule))) },
+		validators: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Validator))) },
+	},
+})
+
+const _UniqueConstraint = new GraphQLObjectType({
+	name: '_UniqueConstraint',
+	fields: {
+		fields: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
+	},
+})
+
+const _Entity = new GraphQLObjectType({
+	name: '_Entity',
+	fields: {
+		name: { type: new GraphQLNonNull(GraphQLString) },
+		customPrimaryAllowed: { type: new GraphQLNonNull(GraphQLBoolean) },
+		fields: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_FieldInterface))) },
+		unique: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_UniqueConstraint))) },
+	},
+})
+
+const _Enum = new GraphQLObjectType({
+	name: '_Enum',
+	fields: {
+		name: { type: new GraphQLNonNull(GraphQLString) },
+		values: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
+	},
+})
+
+const _Schema = new GraphQLObjectType({
+	name: '_Schema',
+	fields: {
+		enums: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Enum))) },
+		entities: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Entity))) },
+	},
+})
+
+
+export const createSchemaConfig = (resolver?: GraphQLFieldResolver<any, any>): GraphQLSchemaConfig => {
+	return {
+		query: new GraphQLObjectType({
+			name: 'Query',
+			fields: {
+				schema: {
+					type: _Schema,
+					resolve: resolver,
+				},
+			},
+		}),
+		types: [_Column, _Relation],
+	}
+}
+
+
+export default new GraphQLSchema(createSchemaConfig())

package/src/mapper/ColumnValue.ts

@@ -1,36 +1,22 @@
 import { Value } from '@contember/schema'
-import { getFulfilledValues, getRejections } from '../utils'
 
-export type ColumnValue<E = never> = {
-	value: PromiseLike<Value.FieldValue<E> | undefined>
+export type ColumnValue = {
+	value: Value.FieldValue
 	fieldName: string
 	columnName: string
 	columnType: string
 }
 
-export type ResolvedColumnValue<E = never> = ColumnValue<E> & {
-	resolvedValue: Value.FieldValue<E>
-}
 
-export const resolveGenericValue = <T>(value: Value.GenericValueLike<T>): Promise<T> => {
-	if (value instanceof Function) {
-		value = value()
-	}
-	return Promise.resolve(value)
-}
+export const rowDataToFieldValues = (values: ColumnValue[]): Record<string, Value.FieldValue> =>
+	Object.fromEntries(values.map(it => [it.fieldName, it.value]))
 
-export const resolveRowData = async <E>(
-	values: ColumnValue<E>[],
-): Promise<ResolvedColumnValue<Exclude<E, undefined>>[]> => {
-	const valuePromises = values.map(async (it): Promise<ResolvedColumnValue<E | undefined>> => ({ ...it, resolvedValue: await it.value }))
-	const settledValues = await Promise.allSettled(valuePromises)
-	const failed = getRejections(settledValues)
-	if (failed.length > 0) {
-		throw failed[0]
+export const normalizeDbValue = (value: Value.FieldValue, type: string): Value.FieldValue => {
+	if (value === null) {
+		return null
 	}
-	const fulfilled = getFulfilledValues(settledValues)
-	return fulfilled.filter((it): it is ResolvedColumnValue<Exclude<E, undefined>> => it.resolvedValue !== undefined)
+	if ((type === 'jsonb' || type === 'json') && typeof value === 'object') {
+		return JSON.stringify(value)
+	}
+	return value
 }
-
-export const rowDataToFieldValues = (values: ResolvedColumnValue[]): Record<string, Value.AtomicValue> =>
-	values.reduce((acc, { fieldName, value }) => ({ ...acc, [fieldName]: value }), {})

package/src/mapper/ErrorUtils.ts

@@ -134,7 +134,7 @@ export const convertError = (
 	if (e instanceof Database.TransactionAbortedError) {
 		return new MutationSqlError([], e.originalMessage, [MutationResultHint.subSequentSqlError])
 	}
-	if (e instanceof Database.QueryError) {
+	if (e instanceof Database.QueryError || e instanceof Database.CannotCommitError) {
 		logger.error(e, { loc: 'convertError' })
 		return new MutationSqlError([], e.originalMessage, [MutationResultHint.sqlError])
 	}