@contember/engine-content-api 1.3.4 → 1.4.0-alpha.1

package/src/schema/ResultSchemaTypeProvider.ts

@@ -12,24 +12,33 @@ import {
 } from 'graphql'
 
 export class ResultSchemaTypeProvider {
+	private fieldPathFragmentType = new GraphQLObjectType({
+		name: '_FieldPathFragment',
+		fields: {
+			field: { type: new GraphQLNonNull(GraphQLString) },
+		},
+	})
+	private indexPathFragmentType = new GraphQLObjectType({
+		name: '_IndexPathFragment',
+		fields: {
+			index: { type: new GraphQLNonNull(GraphQLInt) },
+			alias: { type: GraphQLString },
+		},
+	})
 	private pathFragmentType = new GraphQLUnionType({
 		name: '_PathFragment',
 		types: () => [
-			new GraphQLObjectType({
-				name: '_FieldPathFragment',
-				fields: {
-					field: { type: new GraphQLNonNull(GraphQLString) },
-				},
-			}),
-			new GraphQLObjectType({
-				name: '_IndexPathFragment',
-				fields: {
-					index: { type: new GraphQLNonNull(GraphQLInt) },
-					alias: { type: GraphQLString },
-				},
-			}),
+			this.fieldPathFragmentType,
+			this.indexPathFragmentType,
 		],
 	})
+
+	private validationMessageType = new GraphQLObjectType({
+		name: '_ValidationMessage',
+		fields: {
+			text: { type: new GraphQLNonNull(GraphQLString) },
+		},
+	})
 	private validationErrorType = new GraphQLObjectType({
 		name: '_ValidationError',
 		fields: {
@@ -37,14 +46,7 @@ export class ResultSchemaTypeProvider {
 				type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(this.pathFragmentType))),
 			},
 			message: {
-				type: new GraphQLNonNull(
-					new GraphQLObjectType({
-						name: '_ValidationMessage',
-						fields: {
-							text: { type: new GraphQLNonNull(GraphQLString) },
-						},
-					}),
-				),
+				type: new GraphQLNonNull(this.validationMessageType),
 			},
 		},
 	})
@@ -58,6 +60,11 @@ export class ResultSchemaTypeProvider {
 		},
 	})
 
+	private mutationErrorType = new GraphQLEnumType({
+		name: '_MutationErrorType',
+		values: Object.values(Result.ExecutionErrorType).reduce((acc, type) => ({ ...acc, [type]: {} }), {}),
+	})
+
 	public errorResultType = new GraphQLObjectType({
 		name: '_MutationError',
 		fields: {
@@ -71,12 +78,7 @@ export class ResultSchemaTypeProvider {
 				),
 			},
 			type: {
-				type: new GraphQLNonNull(
-					new GraphQLEnumType({
-						name: '_MutationErrorType',
-						values: Object.values(Result.ExecutionErrorType).reduce((acc, type) => ({ ...acc, [type]: {} }), {}),
-					}),
-				),
+				type: new GraphQLNonNull(this.mutationErrorType),
 			},
 			message: { type: GraphQLString },
 		},

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/graphQlRequests/query/relations/manyHasManyOwning.test.ts

@@ -194,3 +194,48 @@ test('Posts with paginated tags (many has many owning)', async () => {
 })
 
 
+test('large number of posts - use array', async () => {
+	const ids = Array.from({ length: 1000 }).map((it, index) => testUuid(index + 1))
+	await execute({
+		schema: new SchemaBuilder()
+			.entity('Post', entity => entity.manyHasMany('tags', relation => relation.target('Tag')))
+			.entity('Tag', entity => entity.column('name'))
+			.buildSchema(),
+		query: GQL`
+        query {
+          listPost {
+            id
+            tags {
+				name
+            }
+          }
+        }
+			`,
+		executes: [
+			{
+				sql: SQL`select "root_"."id" as "root_id",
+					         "root_"."id" as "root_id"
+				         from "public"."post" as "root_"`,
+				response: {
+					rows: ids.map(id => ({ root_id: id })),
+				},
+			},
+			{
+				sql: SQL`select "junction_"."tag_id", "junction_"."post_id"  from "public"."post_tags" as "junction_"  where "junction_"."post_id" = any(?::uuid[])`,
+				parameters: [ids],
+				response: {
+					rows: [],
+				},
+			},
+		],
+		return: {
+			data: {
+				listPost: ids.map(id => ({
+					id,
+					tags: [],
+				})),
+			},
+		},
+	})
+})
+

package/tests/cases/integration/graphQlSchema/graphQlSchemaBuilder.test.ts

@@ -114,6 +114,30 @@ describe('GraphQL schema builder', () => {
 		})
 	})
 
+	it('read only', async () => {
+		await testSchema({
+			schema: builder =>
+				builder.entity('Test', e =>
+					e
+						.column('a', c => c.type(Model.ColumnType.String))
+						.column('b', c => c.type(Model.ColumnType.String)),
+				),
+			permissions: () => ({
+				Test: {
+					predicates: {},
+					operations: {
+						read: {
+							id: true,
+							a: true,
+							b: true,
+						},
+					},
+				},
+			}),
+			graphQlSchemaFile: 'schema-read-only.gql',
+		})
+	})
+
 
 	it('conditionally restricted read of some fields', async () => {
 		await testSchema({

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/cases/integration/graphQlSchema/schema-read-only.gql

@@ -0,0 +1,116 @@
+type Query {
+  getTest(by: TestUniqueWhere!, filter: TestWhere): Test
+  listTest(filter: TestWhere, orderBy: [TestOrderBy!], offset: Int, limit: Int): [Test!]!
+  paginateTest(filter: TestWhere, orderBy: [TestOrderBy!], skip: Int, first: Int): TestConnection!
+  transaction: QueryTransaction
+  _info: Info
+}
+
+type Test {
+  _meta: TestMeta
+  id: UUID!
+  a: String
+  b: String
+}
+
+type TestMeta {
+  id: FieldMeta
+  a: FieldMeta
+  b: FieldMeta
+}
+
+type FieldMeta {
+  readable: Boolean
+  updatable: Boolean
+}
+
+scalar UUID
+
+input TestUniqueWhere {
+  id: UUID
+}
+
+input TestWhere {
+  id: UUIDCondition
+  a: StringCondition
+  b: StringCondition
+  and: [TestWhere]
+  or: [TestWhere]
+  not: TestWhere
+}
+
+input UUIDCondition {
+  and: [UUIDCondition!]
+  or: [UUIDCondition!]
+  not: UUIDCondition
+  null: Boolean
+  isNull: Boolean
+  eq: UUID
+  notEq: UUID
+  in: [UUID!]
+  notIn: [UUID!]
+  lt: UUID
+  lte: UUID
+  gt: UUID
+  gte: UUID
+}
+
+input StringCondition {
+  and: [StringCondition!]
+  or: [StringCondition!]
+  not: StringCondition
+  null: Boolean
+  isNull: Boolean
+  eq: String
+  notEq: String
+  in: [String!]
+  notIn: [String!]
+  lt: String
+  lte: String
+  gt: String
+  gte: String
+  contains: String
+  startsWith: String
+  endsWith: String
+  containsCI: String
+  startsWithCI: String
+  endsWithCI: String
+}
+
+input TestOrderBy {
+  _random: Boolean
+  _randomSeeded: Int
+  id: OrderDirection
+  a: OrderDirection
+  b: OrderDirection
+}
+
+enum OrderDirection {
+  asc
+  desc
+  ascNullsFirst
+  descNullsLast
+}
+
+type TestConnection {
+  pageInfo: PageInfo!
+  edges: [TestEdge!]!
+}
+
+type PageInfo {
+  totalCount: Int!
+}
+
+type TestEdge {
+  node: Test!
+}
+
+type QueryTransaction {
+  getTest(by: TestUniqueWhere!, filter: TestWhere): Test
+  listTest(filter: TestWhere, orderBy: [TestOrderBy!], offset: Int, limit: Int): [Test!]!
+  paginateTest(filter: TestWhere, orderBy: [TestOrderBy!], skip: Int, first: Int): TestConnection!
+}
+
+type Info {
+  description: String
+}

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"}