@contember/engine-content-api 1.3.4 → 1.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -13,21 +13,20 @@
     "test": "vitest --dir ./tests/cases --no-threads"
   },
   "dependencies": {
-    "@contember/database": "1.3.4",
-    "@contember/dic": "1.3.4",
-    "@contember/graphql-utils": "1.3.4",
-    "@contember/logger": "1.3.4",
-    "@contember/schema": "1.3.4",
-    "@contember/schema-definition": "1.3.4",
-    "@contember/schema-utils": "1.3.4",
-    "@graphql-tools/schema": "^8.3.5",
+    "@contember/database": "1.3.6",
+    "@contember/dic": "1.3.6",
+    "@contember/graphql-utils": "1.3.6",
+    "@contember/logger": "1.3.6",
+    "@contember/schema": "1.3.6",
+    "@contember/schema-definition": "1.3.6",
+    "@contember/schema-utils": "1.3.6",
     "fast-deep-equal": "^3.1.3",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "1.3.4",
-    "@contember/engine-api-tester": "1.3.4",
-    "@contember/schema-definition": "1.3.4",
+    "@contember/database-tester": "1.3.6",
+    "@contember/engine-api-tester": "1.3.6",
+    "@contember/schema-definition": "1.3.6",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/introspection/IntrospectionSchemaDefinitionFactory.ts

@@ -1,21 +1,202 @@
-import { IExecutableSchemaDefinition } from '@graphql-tools/schema'
-import schema from './content-schema.graphql'
 import * as ContentSchema from './content-schema.types'
 import { IntrospectionSchemaFactory } from './IntrospectionSchemaFactory'
+import { JSONType } from '@contember/graphql-utils'
+
+import {
+	GraphQLBoolean,
+	GraphQLEnumType,
+	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 class IntrospectionSchemaDefinitionFactory {
 	constructor(private readonly introspectionSchemaFactory: IntrospectionSchemaFactory) {}
 
-	public create(): IExecutableSchemaDefinition {
+	public create(): GraphQLSchema {
+		return new GraphQLSchema(this.createConfig())
+	}
+
+	public createConfig(): GraphQLSchemaConfig {
 		return {
-			typeDefs: schema,
-			resolvers: {
-				Query: {
-					schema: (): ContentSchema._Schema => {
-						return this.introspectionSchemaFactory.create()
+			query: new GraphQLObjectType({
+				name: 'Query',
+				fields: {
+					schema: {
+						type: _Schema,
+						resolve: (): ContentSchema._Schema => {
+							return this.introspectionSchemaFactory.create()
+						},
 					},
 				},
-			},
+			}),
+			types: [_Column, _Relation],
 		}
 	}
 }

package/src/mapper/select/RelationFetcher.ts

@@ -118,7 +118,7 @@ export class RelationFetcher {
 
 		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
 
-		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, relationContext.targetEntity, { filter }, [
+		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, relationContext.targetEntity, relationContext.entity, { filter }, [
 			...relationPath,
 			relationContext,
 		])
@@ -146,13 +146,14 @@ export class RelationFetcher {
 		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
 		const defaultOrderBy = relationContext.relation.orderBy
 		const objectNode = OrderByHelper.appendDefaultOrderBy(relationContext.targetEntity, field, defaultOrderBy)
-		const { targetEntity } = relationContext
+		const { targetEntity, entity } = relationContext
 		const junctionValues = await this.fetchJunction(
 			mapper.db,
 			owningRelation,
 			ids,
 			joiningColumns,
 			targetEntity,
+			entity,
 			objectNode,
 			[...relationPath, relationContext],
 		)
@@ -219,11 +220,12 @@ export class RelationFetcher {
 		values: Input.PrimaryValue[],
 		column: JoiningColumns,
 		targetEntity: Model.Entity,
+		sourceEntity: Model.Entity,
 		object: ObjectNode<Input.ListQueryInput>,
 		relationPath: Model.AnyRelationContext[],
 	): Promise<Record<string, Value.AtomicValue>[]> {
 		const joiningTable = relation.joiningTable
-		const qb = this.buildJunctionQb(relation, values, column, targetEntity, object.args, relationPath)
+		const qb = this.buildJunctionQb(relation, values, column, targetEntity, sourceEntity, object.args, relationPath)
 			.select(['junction_', joiningTable.inverseJoiningColumn.columnName])
 			.select(['junction_', joiningTable.joiningColumn.columnName])
 		const wrapper = new LimitByGroupWrapper(
@@ -252,15 +254,17 @@ export class RelationFetcher {
 		ids: Input.PrimaryValue[],
 		column: JoiningColumns,
 		targetEntity: Model.Entity,
+		sourceEntity: Model.Entity,
 		objectArgs: Input.ListQueryInput,
 		relationPath: Model.AnyRelationContext[],
 	): SelectBuilder {
 		const joiningTable = relation.joiningTable
 
 		const whereColumn = column.sourceColumn.columnName
+		const primaryColumn = sourceEntity.fields[sourceEntity.primary] as Model.AnyColumn
 		let qb = SelectBuilder.create()
 			.from(joiningTable.tableName, 'junction_')
-			.where(clause => clause.in(['junction_', whereColumn], ids))
+			.where(clause => clause.in(['junction_', whereColumn], ids, primaryColumn.columnType))
 
 		const where = this.predicateInjector.inject(targetEntity, objectArgs.filter || {}, relationPath[relationPath.length - 1])
 		const hasWhere = where && Object.keys(where).length > 0

package/src/schema/GraphQlSchemaBuilder.ts

@@ -1,10 +1,13 @@
 import {
-	GraphQLFieldConfig,
 	GraphQLBoolean,
+	GraphQLFieldConfig,
+	GraphQLInputObjectType,
+	GraphQLNamedType,
 	GraphQLNonNull,
 	GraphQLObjectType,
 	GraphQLSchema,
-	GraphQLString, GraphQLInputObjectType,
+	GraphQLSchemaConfig,
+	GraphQLString,
 } from 'graphql'
 import { Model } from '@contember/schema'
 import { MutationProvider } from './MutationProvider'
@@ -13,6 +16,12 @@ import { ValidationQueriesProvider } from './ValidationQueriesProvider'
 import { Context } from '../types'
 import { ResultSchemaTypeProvider } from './ResultSchemaTypeProvider'
 
+type BuildArgs = {
+	queries?: Map<string, GraphQLFieldConfig<any, Context, any>>
+	mutations?: Map<string, GraphQLFieldConfig<any, Context, any>>
+	types?: GraphQLNamedType[]
+}
+
 export class GraphQlSchemaBuilder {
 	constructor(
 		private readonly schema: Model.Schema,
@@ -22,9 +31,13 @@ export class GraphQlSchemaBuilder {
 		private readonly resultSchemaTypeProvider: ResultSchemaTypeProvider,
 	) {}
 
-	public build(): GraphQLSchema {
-		const queries = new Map<string, GraphQLFieldConfig<any, Context, any>>()
-		const mutations = new Map<string, GraphQLFieldConfig<any, Context, any>>()
+	public build(args: BuildArgs = {}): GraphQLSchema {
+		return new GraphQLSchema(this.buildConfig(args))
+	}
+
+	private buildConfig(args: BuildArgs): GraphQLSchemaConfig {
+		const queries = new Map<string, GraphQLFieldConfig<any, Context, any>>(args.queries)
+		const mutations = new Map<string, GraphQLFieldConfig<any, Context, any>>(args.mutations)
 		for (const entity of Object.values(this.schema.entities)) {
 			const queryFields = this.queryProvider.getQueries(entity)
 			for (const name in queryFields) {
@@ -41,11 +54,12 @@ export class GraphQlSchemaBuilder {
 		}
 
 		if (queries.size > 0) {
+			const queryTransactionType = new GraphQLObjectType({
+				name: 'QueryTransaction',
+				fields: Object.fromEntries(queries),
+			})
 			queries.set('transaction', {
-				type: new GraphQLObjectType({
-					name: 'QueryTransaction',
-					fields: Object.fromEntries(queries),
-				}),
+				type: queryTransactionType,
 				resolve: async (parent, args, context: Context, info) => {
 					return context.timer(`GraphQL.query.${info.fieldName}`, () =>
 						context.executionContainer.readResolver.resolveTransaction(info),
@@ -58,33 +72,35 @@ export class GraphQlSchemaBuilder {
 			fields: () => Object.fromEntries(queries),
 		})
 		if (mutations.size > 0) {
+			const mutationTransactionOptions = new GraphQLInputObjectType({
+				name: 'MutationTransactionOptions',
+				fields: {
+					deferForeignKeyConstraints: { type: GraphQLBoolean },
+				},
+			})
+			const mutationTransactionType = new GraphQLObjectType({
+				name: 'MutationTransaction',
+				fields: {
+					ok: { type: new GraphQLNonNull(GraphQLBoolean) },
+					errorMessage: { type: GraphQLString },
+					errors: { type: this.resultSchemaTypeProvider.errorListResultType },
+					validation: {
+						type: new GraphQLNonNull(this.resultSchemaTypeProvider.validationResultType),
+					},
+					...Object.fromEntries(mutations),
+					query: {
+						type: queryObjectType,
+					},
+				},
+			})
 			mutations.set('transaction', {
 				args: {
 					options: {
-						type: new GraphQLInputObjectType({
-							name: 'MutationTransactionOptions',
-							fields: {
-								deferForeignKeyConstraints: { type: GraphQLBoolean },
-							},
-						}),
+						type: mutationTransactionOptions,
 					},
 				},
 				type: new GraphQLNonNull(
-					new GraphQLObjectType({
-						name: 'MutationTransaction',
-						fields: {
-							ok: { type: new GraphQLNonNull(GraphQLBoolean) },
-							errorMessage: { type: GraphQLString },
-							errors: { type: this.resultSchemaTypeProvider.errorListResultType },
-							validation: {
-								type: new GraphQLNonNull(this.resultSchemaTypeProvider.validationResultType),
-							},
-							...Object.fromEntries(mutations),
-							query: {
-								type: queryObjectType,
-							},
-						},
-					}),
+					mutationTransactionType,
 				),
 				resolve: async (parent, args: { options?: { deferForeignKeyConstraints?: boolean } }, context: Context, info) => {
 					return context.timer(`GraphQL.mutation.${info.fieldName}`, () =>
@@ -99,28 +115,31 @@ export class GraphQlSchemaBuilder {
 				resolve: (parent, args, context: Context, info) => context.executionContainer.readResolver.resolveQuery(info),
 			})
 		}
-		queries.set('_info', {
-			type: new GraphQLObjectType({
-				name: 'Info',
-				fields: () => ({
-					description: { type: GraphQLString },
-				}),
+		const infoType = new GraphQLObjectType({
+			name: 'Info',
+			fields: () => ({
+				description: { type: GraphQLString },
 			}),
+		})
+		queries.set('_info', {
+			type: infoType,
 			resolve: () => ({
 				description: 'TODO',
 			}),
 		})
 
-		return new GraphQLSchema({
+
+		return {
 			query: queryObjectType,
+			types: args.types,
 			...(mutations.size > 0
 				? {
 					mutation: new GraphQLObjectType({
 						name: 'Mutation',
 						fields: () => Object.fromEntries(mutations),
 					}),
-				  }
+				}
 				: {}),
-		})
+		}
 	}
 }

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/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({