@contember/engine-content-api 1.3.6 → 1.4.0-alpha.2

package/src/resolvers/MutationResolver.ts

@@ -3,6 +3,7 @@ import {
 	AfterCommitEvent,
 	BeforeCommitEvent,
 	ConstraintType,
+	convertError,
 	getInsertPrimary,
 	InputErrorKind,
 	Mapper,
@@ -16,18 +17,20 @@ import { ValidationResolver } from './ValidationResolver'
 import { GraphQLResolveInfo } from 'graphql'
 import { GraphQlQueryAstFactory } from './GraphQlQueryAstFactory'
 import { ImplementationException } from '../exception'
-import { retryTransaction } from '@contember/database'
+import { DatabaseMetadata, 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'>>
 
-type TransactionOptions = { deferForeignKeyConstraints?: boolean }
+type TransactionOptions = {
+	deferForeignKeyConstraints?: boolean
+	deferUniqueConstraints?: boolean
+}
 
 export class MutationResolver {
 	constructor(
@@ -35,7 +38,7 @@ export class MutationResolver {
 		private readonly mapperFactory: MapperFactory,
 		private readonly inputValidator: InputPreValidator,
 		private readonly graphqlQueryAstFactory: GraphQlQueryAstFactory,
-		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly schemaDatabaseMetadata: DatabaseMetadata,
 	) {}
 
 	public async resolveTransaction(info: GraphQLResolveInfo, options: TransactionOptions): Promise<Result.TransactionResult> {
@@ -65,7 +68,11 @@ export class MutationResolver {
 		return this.transaction(async mapper => {
 			if (options?.deferForeignKeyConstraints) {
 				logger.debug('MutationResolver: deferring foreign constraints')
-				await mapper.constraintHelper.setFkConstraintsDeferred()
+				await mapper.constraintHelper.setConstraintsDeferred('foreignKey')
+			}
+			if (options?.deferUniqueConstraints) {
+				logger.debug('MutationResolver: deferring unique constraints')
+				await mapper.constraintHelper.setConstraintsDeferred('unique')
 			}
 			const validationResult: Record<string, Result.MutationFieldResult> = {}
 			const validationErrors: Result.ValidationError[] = []
@@ -196,18 +203,6 @@ export class MutationResolver {
 				}
 				trxResult[field.alias] = result
 			}
-			if (options?.deferForeignKeyConstraints) {
-				logger.debug('MutationResolver: validating fk constraints')
-				const constraintsResult = await tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
-					await mapper.constraintHelper.setFkConstraintsImmediate()
-					return []
-				})
-				const errorResponse = this.createErrorResponse(constraintsResult)
-				if (errorResponse) {
-					logger.debug('MutationResolver: deferred fk validation failed', { errorResponse })
-					return { ...errorResponse, ...validationResult }
-				}
-			}
 
 			return {
 				__typename: 'MutationTransaction',
@@ -474,20 +469,31 @@ export class MutationResolver {
 	): Promise<R> {
 		return await retryTransaction(
 			async () => {
-				const [result, mapper] = await this.mapperFactory.transaction(async mapper => {
+				return await this.mapperFactory.transaction(async mapper => {
 					logger.debug('MutationResolver: Starting mutation transaction')
 					const result = await cb(mapper)
 					if (!result.ok) {
 						logger.debug('MutationResolver: Transaction failed, rolling back', { result })
 						await mapper.db.connection.rollback()
 					} else {
+						await mapper.eventManager.fire(new BeforeCommitEvent())
+
 						logger.debug('MutationResolver: Transaction ok, committing')
+						try {
+							await mapper.db.connection.commit()
+						} catch (e) {
+							const err = convertError(this.schema, this.schemaDatabaseMetadata, e)
+							const errorResponse = this.createErrorResponse([err])
+							if (!errorResponse) {
+								throw new ImplementationException()
+							}
+							return { ...result, ...errorResponse }
+						}
+
+						await mapper.eventManager.fire(new AfterCommitEvent())
 					}
-					await mapper.eventManager.fire(new BeforeCommitEvent())
-					return [result, mapper]
+					return result
 				})
-				await mapper.eventManager.fire(new AfterCommitEvent())
-				return result
 			},
 			message => logger.warn(message),
 			{
@@ -496,6 +502,7 @@ export class MutationResolver {
 				maxTimeout: 1000,
 			},
 		)
+
 	}
 
 	private createErrorResponse(result: MutationResultList) {

package/src/schema/EntityTypeProvider.ts

@@ -46,7 +46,8 @@ export class EntityTypeProvider {
 		private readonly columnTypeResolver: ColumnTypeResolver,
 		private readonly whereTypeProvider: WhereTypeProvider,
 		private readonly orderByTypeProvider: OrderByTypeProvider,
-	) {}
+	) {
+	}
 
 	public registerEntityFieldProvider(key: string, provider: EntityFieldsProvider): void {
 		this.entityFieldProviders[key] = provider
@@ -76,19 +77,16 @@ 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.keys(entity.fields).filter(fieldName =>
-			acceptFieldVisitor(this.schema, entity, fieldName, accessVisitor),
-		)
-		const metaFields: { [field: string]: GraphQLFieldConfig<any, any> } = accessibleFields.reduce(
-			(result, fieldName) => ({
-				...result,
-				[fieldName]: {
-					type: this.fieldMeta,
-					resolve: aliasAwareResolver,
-				},
-			}),
-			{},
+		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] = {
+				type: this.fieldMeta,
+				resolve: aliasAwareResolver,
+			}
+		}
 
 		const metaField = {
 			type: new GraphQLObjectType({
@@ -98,36 +96,29 @@ export class EntityTypeProvider {
 			resolve: aliasAwareResolver,
 		}
 
-		const fields: { [field: string]: GraphQLFieldConfig<any, any> } = accessibleFields.reduce(
-			(result, fieldName) => {
-				const fieldTypeVisitor = new FieldTypeVisitor(this.columnTypeResolver, this, this.authorizator)
-				const type: GraphQLOutputType = acceptFieldVisitor(this.schema, entity, fieldName, fieldTypeVisitor)
+		let fields: { [field: string]: GraphQLFieldConfig<any, any> } = {
+			_meta: metaField,
+		}
+
+		for (const field of accessibleFields) {
+			const fieldTypeVisitor = new FieldTypeVisitor(this.columnTypeResolver, this, this.authorizator)
+			const type: GraphQLOutputType = acceptFieldVisitor(this.schema, entity, field.name, fieldTypeVisitor)
 
-				const fieldArgsVisitor = new FieldArgsVisitor(this.whereTypeProvider, this.orderByTypeProvider)
-				return {
-					...result,
-					[fieldName]: {
-						type,
-						args: acceptFieldVisitor(this.schema, entity, fieldName, fieldArgsVisitor),
-						resolve: aliasAwareResolver,
-					},
-				}
-			},
-			{
-				_meta: metaField,
-			},
-		)
+			const fieldArgsVisitor = new FieldArgsVisitor(this.whereTypeProvider, this.orderByTypeProvider)
+			fields[field.name] = {
+				type,
+				args: acceptFieldVisitor(this.schema, entity, field.name, fieldArgsVisitor),
+				resolve: aliasAwareResolver,
+			}
+		}
 
-		return Object.entries(this.entityFieldProviders)
-			.map(([key, provider]) =>
-				Object.entries(provider.getFields(entity, accessibleFields))
-					.map(([fieldName, fieldConfig]): [string, GraphQLFieldConfig<any, any>] => [
-						fieldName,
-						{ ...fieldConfig, extensions: { ...(fieldConfig.extensions || {}), extensionKey: key } },
-					])
-					.reduce((result, [name, value]) => ({ ...result, [name]: value }), {}),
-			)
-			.reduce((result, providerFields) => ({ ...result, ...providerFields }), fields)
+		for (const [key, provider] of Object.entries(this.entityFieldProviders)) {
+			fields = {
+				...fields,
+				...provider.getFields(entity, accessibleFields),
+			}
+		}
+		return fields
 	}
 
 	private createConnection(entityName: string) {

package/src/schema/GraphQlSchemaBuilder.ts

@@ -76,6 +76,7 @@ export class GraphQlSchemaBuilder {
 				name: 'MutationTransactionOptions',
 				fields: {
 					deferForeignKeyConstraints: { type: GraphQLBoolean },
+					deferUniqueConstraints: { type: GraphQLBoolean },
 				},
 			})
 			const mutationTransactionType = new GraphQLObjectType({
@@ -102,10 +103,11 @@ export class GraphQlSchemaBuilder {
 				type: new GraphQLNonNull(
 					mutationTransactionType,
 				),
-				resolve: async (parent, args: { options?: { deferForeignKeyConstraints?: 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,
 						}),
 					)
 				},

package/tests/cases/integration/graphQlDb/update/deferedConstraints.test.ts

@@ -196,7 +196,7 @@ test('delete with unsuccessfully deferring constraints', async () => {
 				ok: false,
 				errorMessage: 'Execution has failed:\nunknown field: ForeignKeyConstraintViolation (Cannot delete row 123e4567-e89b-12d3-a456-000000000004 of entity Attachment, because it is still referenced from Reference::attachment. This is possibly caused by ACL denial or by missing "on delete cascade")',
 				updatePost: {
-					ok: false,
+					ok: true,
 					errorMessage: null,
 				},
 			},

package/tests/cases/integration/graphQlDb/update/deferredUniqueConstraints.test.ts

@@ -0,0 +1,169 @@
+import { test } from 'vitest'
+import { c, createSchema } from '@contember/schema-definition'
+import { GQL } from '../../../../src/tags'
+import { testUuid } from '../../../../src/testUuid'
+import { executeDbTest } from '@contember/engine-api-tester'
+
+namespace DeferredUniqueModel {
+	export class Post {
+		slug = c.stringColumn().unique()
+		order = c.intColumn().unique({ timing: 'deferrable' })
+	}
+}
+
+test('update without deferring unique constraints', async () => {
+	await executeDbTest({
+		schema: createSchema(DeferredUniqueModel),
+		seed: [
+			{
+				query: `mutation {
+					postA: createPost(data: {slug: "a", order: 1}) {
+						ok
+						node {
+							id
+						}
+					}
+					postB: createPost(data: {slug: "b", order: 2}) {
+						ok
+						node {
+							id
+						}
+					}
+				}`,
+			},
+		],
+		query: GQL`
+			mutation {
+				transaction {
+					ok
+					errorMessage
+					upA: updatePost(by: {slug: "a"}, data: {order: 2}) {
+						ok
+						errorMessage
+					}
+					upB: updatePost(by: {slug: "b"}, data: {order: 1}) {
+						ok
+						errorMessage
+					}
+				}
+			}
+		`,
+		return: {
+			transaction: {
+				ok: false,
+				errorMessage: 'Execution has failed:\nupA.order: UniqueConstraintViolation (Value (2) already exists in unique columns (order) on entity Post)',
+				upA: {
+					ok: false,
+					errorMessage: 'Execution has failed:\norder: UniqueConstraintViolation (Value (2) already exists in unique columns (order) on entity Post)',
+				},
+				upB: {
+					ok: false,
+					errorMessage: null,
+				},
+			},
+		},
+	})
+})
+
+test('update with deferring unique constraints', async () => {
+	await executeDbTest({
+		schema: createSchema(DeferredUniqueModel),
+		seed: [
+			{
+				query: `mutation {
+				
+					postA: createPost(data: {slug: "a", order: 1}) {
+						ok
+						node {
+							id
+						}
+					}
+					postB: createPost(data: {slug: "b", order: 2}) {
+						ok
+						node {
+							id
+						}
+					}
+				}`,
+			},
+		],
+		query: GQL`
+			mutation {
+				transaction(options: {deferUniqueConstraints: true}) {
+					ok
+					errorMessage
+					upA: updatePost(by: {slug: "a"}, data: {order: 2}) {
+						ok
+						errorMessage
+					}
+					upB: updatePost(by: {slug: "b"}, data: {order: 1}) {
+						ok
+						errorMessage
+					}
+				}
+			}
+		`,
+		return: {
+			transaction: {
+				ok: true,
+				errorMessage: null,
+				upA: {
+					ok: true,
+					errorMessage: null,
+				},
+				upB: {
+					ok: true,
+					errorMessage: null,
+				},
+			},
+		},
+	})
+})
+
+
+test('update with failed deferred unique constraints', async () => {
+	await executeDbTest({
+		schema: createSchema(DeferredUniqueModel),
+		seed: [
+			{
+				query: `mutation {
+				
+					postA: createPost(data: {slug: "a", order: 1}) {
+						ok
+						node {
+							id
+						}
+					}
+					postB: createPost(data: {slug: "b", order: 2}) {
+						ok
+						node {
+							id
+						}
+					}
+				}`,
+			},
+		],
+		query: GQL`
+			mutation {
+				transaction(options: {deferUniqueConstraints: true}) {
+					ok
+					errorMessage
+					upA: updatePost(by: {slug: "a"}, data: {order: 2}) {
+						ok
+						errorMessage
+					}
+				}
+			}
+		`,
+		return: {
+			transaction: {
+				ok: false,
+				errorMessage: 'Execution has failed:\norder: UniqueConstraintViolation (Value (2) already exists in unique columns (order) on entity Post)',
+				upA: {
+					ok: true,
+					errorMessage: null,
+				},
+			},
+		},
+	})
+})

package/tests/cases/integration/graphQlSchema/schema-acl-allowed.gql

@@ -417,4 +417,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-acl-create-only.gql

@@ -226,4 +226,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-acl-restricted-create.gql

@@ -306,4 +306,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-acl-restricted-delete.gql

@@ -399,4 +399,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-acl-restricted-update.gql

@@ -335,4 +335,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-acl.gql

@@ -218,4 +218,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-aliased-type.gql

@@ -223,4 +223,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-basic.gql

@@ -838,4 +838,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-bug-66.gql

@@ -537,4 +537,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-custom-primary.gql

@@ -848,4 +848,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-has-many-reduction.gql

@@ -450,4 +450,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/cases/integration/graphQlSchema/schema-new-builder.gql

@@ -909,4 +909,5 @@ type MutationTransaction {
 
 input MutationTransactionOptions {
   deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
 }

package/tests/src/test.ts

@@ -1,8 +1,8 @@
 import { Acl, Model, Schema, Validation } from '@contember/schema'
 import { Authorizator, GraphQlSchemaBuilderFactory, ExecutionContainerFactory } from '../../src'
-import { AllowAllPermissionFactory, dummySchemaDatabaseMetadata, emptySchema } from '@contember/schema-utils'
+import { AllowAllPermissionFactory, emptySchema } from '@contember/schema-utils'
 import { executeGraphQlTest } from './testGraphql'
-import { Client } from '@contember/database'
+import { Client, emptyDatabaseMetadata } from '@contember/database'
 import { createConnectionMock } from '@contember/database-tester'
 import { createUuidGenerator } from '@contember/engine-api-tester'
 import { SQL } from './tags'
@@ -111,7 +111,7 @@ export const execute = async (test: Test) => {
 					systemSchema: 'system',
 					stage: { id: '00000000-0000-0000-0000-000000000000', slug: 'live' },
 					project: { slug: 'test' },
-					schemaDatabaseMetadata: dummySchemaDatabaseMetadata,
+					schemaDatabaseMetadata: emptyDatabaseMetadata,
 				}),
 			timer: (label: any, cb: any) => cb(),
 		},

package/dist/src/introspection/content-schema.graphql.d.ts

@@ -1,4 +0,0 @@
-import { DocumentNode } from 'graphql';
-declare const schema: DocumentNode;
-export default schema;
-//# sourceMappingURL=content-schema.graphql.d.ts.map

package/dist/src/introspection/content-schema.graphql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"content-schema.graphql.d.ts","sourceRoot":"","sources":["../../../src/introspection/content-schema.graphql.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAEtC,QAAA,MAAM,MAAM,EAAE,YA2Gb,CAAA;AAED,eAAe,MAAM,CAAA"}

package/dist/src/introspection/content-schema.graphql.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const graphql_tag_1 = require("graphql-tag");
-const schema = (0, graphql_tag_1.gql) `
-	scalar Json
-
-	type Query {
-		schema: _Schema
-	}
-
-	type _Schema {
-		enums: [_Enum!]!
-		entities: [_Entity!]!
-	}
-
-	type _Entity {
-		name: String!
-		customPrimaryAllowed: Boolean!
-		fields: [_Field!]!
-		unique: [_UniqueConstraint!]!
-	}
-
-	type _UniqueConstraint {
-		fields: [String!]!
-	}
-
-	interface _Field {
-		name: String!
-		type: String!
-		nullable: Boolean
-		rules: [_Rule!]!
-		validators: [_Validator!]!
-	}
-
-	type _Column implements _Field {
-		name: String!
-		type: String!
-		enumName: String
-		defaultValue: Json
-		nullable: Boolean!
-		rules: [_Rule!]!
-		validators: [_Validator!]!
-	}
-
-	enum _OnDeleteBehaviour {
-		restrict
-		cascade
-		setNull
-	}
-
-	enum _RelationSide {
-		owning
-		inverse
-	}
-	enum _OrderByDirection {
-		asc
-		desc
-	}
-	type _OrderBy {
-		path: [String!]!
-		direction: _OrderByDirection!
-	}
-
-	type _Relation implements _Field {
-		name: String!
-		type: String!
-		side: _RelationSide!
-		targetEntity: String!
-		ownedBy: String
-		inversedBy: String
-		nullable: Boolean
-		onDelete: _OnDeleteBehaviour
-		orphanRemoval: Boolean
-		orderBy: [_OrderBy!]
-		rules: [_Rule!]!
-		validators: [_Validator!]!
-	}
-
-	type _Rule {
-		message: _RuleMessage
-		validator: Int!
-	}
-
-	type _Validator {
-		operation: String!
-		arguments: [_Argument!]!
-	}
-
-	union _Argument = _ValidatorArgument | _PathArgument | _LiteralArgument
-
-	type _ValidatorArgument {
-		validator: Int!
-	}
-
-	type _PathArgument {
-		path: [String!]!
-	}
-
-	type _LiteralArgument {
-		value: Json
-	}
-
-	type _RuleMessage {
-		text: String
-	}
-
-	type _Enum {
-		name: String!
-		values: [String!]!
-	}
-`;
-exports.default = schema;
-//# sourceMappingURL=content-schema.graphql.js.map

package/dist/src/introspection/content-schema.graphql.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"content-schema.graphql.js","sourceRoot":"","sources":["../../../src/introspection/content-schema.graphql.ts"],"names":[],"mappings":";;AAAA,6CAAiC;AAGjC,MAAM,MAAM,GAAiB,IAAA,iBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2G/B,CAAA;AAED,kBAAe,MAAM,CAAA"}