@contember/engine-content-api 1.0.0 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,19 +10,19 @@
     "test": "uvu dist/tests/cases/ \\.js$"
   },
   "dependencies": {
-    "@contember/database": "^1.0.0",
-    "@contember/dic": "^1.0.0",
-    "@contember/engine-common": "^1.0.0",
-    "@contember/graphql-utils": "^1.0.0",
-    "@contember/schema": "^1.0.0",
-    "@contember/schema-utils": "^1.0.0",
+    "@contember/database": "^1.0.3",
+    "@contember/dic": "^1.0.3",
+    "@contember/engine-common": "^1.0.3",
+    "@contember/graphql-utils": "^1.0.3",
+    "@contember/schema": "^1.0.3",
+    "@contember/schema-utils": "^1.0.3",
     "@graphql-tools/schema": "^7.1.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.0.0",
-    "@contember/engine-api-tester": "^1.0.0",
-    "@contember/schema-definition": "^1.0.0",
+    "@contember/database-tester": "^1.0.3",
+    "@contember/engine-api-tester": "^1.0.3",
+    "@contember/schema-definition": "^1.0.3",
     "@graphql-codegen/cli": "^1.15.2",
     "@graphql-codegen/typescript": "^1.15.2",
     "@graphql-codegen/typescript-operations": "^1.15.2",

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor.ts

@@ -3,6 +3,7 @@ import { FieldMap } from '../EntityFieldsProvider'
 import { PaginatedHasManyFieldProviderExtension } from './PaginatedHasManyFieldProvider'
 import { capitalizeFirstLetter } from '../../utils'
 import { PaginatedFieldConfigFactory } from '../../schema/PaginatedFieldConfigFactory'
+import { aliasAwareResolver } from '../../schema'
 
 export class PaginatedHasManyFieldProviderVisitor implements
 	Model.ColumnVisitor<FieldMap<PaginatedHasManyFieldProviderExtension>>,
@@ -47,6 +48,7 @@ export class PaginatedHasManyFieldProviderVisitor implements
 				extensions: {
 					relationName: relation.name,
 				},
+				resolve: aliasAwareResolver,
 			},
 		}
 	}

package/src/mapper/Mapper.ts

@@ -120,11 +120,8 @@ export class Mapper {
 		const selector = this.selectBuilderFactory.create(augmentedBuilder, hydrator)
 		const filterWithPredicates = this.predicatesInjector.inject(entity, inputWithOrder.args.filter || {})
 		const inputWithPredicates = inputWithOrder.withArg('filter', filterWithPredicates)
-		const selectPromise = selector.select(this, entity, inputWithPredicates, path, groupBy)
-		const rows = await selector.execute(this.db)
-		await selectPromise
-
-		return rows
+		selector.select(this, entity, inputWithPredicates, path, groupBy)
+		return await selector.execute(this.db)
 	}
 
 	public async count(entity: Model.Entity, filter: Input.OptionalWhere) {

package/src/mapper/select/ConditionBuilder.ts

@@ -7,6 +7,7 @@ export class ConditionBuilder {
 		builder: SqlConditionBuilder,
 		tableName: string,
 		columnName: string,
+		columnType: string,
 		condition: Input.Condition<any>,
 	): SqlConditionBuilder {
 		const keys = Object.keys(condition) as (keyof Required<Input.Condition<any>>)[]
@@ -27,13 +28,13 @@ export class ConditionBuilder {
 				param: Exclude<Input.Condition<any>[K], undefined>,
 			) => SqlConditionBuilder
 		} = {
-			and: (builder, expressions) => builder.and(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, expr), builder2)),
-			or: (builder, expressions) => builder.or(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, expr), builder2)),
-			not: (builder, expression) => builder.not(builder2 => this.build(builder2, tableName, columnName, expression)),
+			and: (builder, expressions) => builder.and(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, columnType, expr), builder2)),
+			or: (builder, expressions) => builder.or(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, columnType, expr), builder2)),
+			not: (builder, expression) => builder.not(builder2 => this.build(builder2, tableName, columnName, columnType, expression)),
 			eq: (builder, value) => builder.compare(columnIdentifier, Operator.eq, value),
 			notEq: (builder, value) => builder.compare(columnIdentifier, Operator.notEq, value),
 			isNull: (builder, value) => value ? builder.isNull(columnIdentifier) : builder.not(clause => clause.isNull(columnIdentifier)),
-			in: (builder, values) => builder.in(columnIdentifier, values),
+			in: (builder, values) => builder.in(columnIdentifier, values, columnType),
 			notIn: (builder, values) => builder.not(builder2 => builder2.in(columnIdentifier, values)),
 			lt: (builder, value) => builder.compare(columnIdentifier, Operator.lt, value),
 			lte: (builder, value) => builder.compare(columnIdentifier, Operator.lte, value),

package/src/mapper/select/JoinVisitor.ts

@@ -70,7 +70,7 @@ export class JoinVisitor implements Model.RelationByTypeVisitor<JoinDefinition[]
 	): JoinDefinition[] {
 		const sourceAlias = this.path.back().getAlias()
 		const targetAlias = this.path.getAlias()
-		const joiningAlias = `${sourceAlias}_x_${targetAlias}`
+		const joiningAlias = this.path.back().for('x_' + this.path.getAlias()).getAlias()
 		return [
 			{
 				tableName: relation.joiningTable.tableName,
@@ -98,7 +98,7 @@ export class JoinVisitor implements Model.RelationByTypeVisitor<JoinDefinition[]
 	): JoinDefinition[] {
 		const sourceAlias = this.path.back().getAlias()
 		const targetAlias = this.path.getAlias()
-		const joiningAlias = `${sourceAlias}_x_${targetAlias}`
+		const joiningAlias = this.path.back().for('x_' + this.path.getAlias()).getAlias()
 		return [
 			{
 				tableName: targetRelation.joiningTable.tableName,

package/src/mapper/select/OrderByBuilder.ts

@@ -30,7 +30,7 @@ export class OrderByBuilder {
 	): [SelectBuilder<SelectBuilder.Result>, Orderable] {
 		const entries = Object.entries(orderBy)
 		if (entries.length !== 1) {
-			const fields = entries.join(', ')
+			const fields = entries.map(it => it[0]).join(', ')
 			throw new UserError('Order by: only one field is expected in each item of order by clause, got: ' + fields)
 		}
 		if (orderBy._random || orderBy._randomSeeded) {

package/src/mapper/select/SelectBuilder.ts

@@ -43,14 +43,14 @@ export class SelectBuilder {
 		return result
 	}
 
-	public async select(
+	public select(
 		mapper: Mapper,
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
 		path: Path,
 		groupBy?: string,
 	) {
-		const promise = this.selectInternal(mapper, entity, path, input)
+		this.selectInternal(mapper, entity, path, input)
 		const where = input.args.filter
 		if (where) {
 			this.qb = this.whereBuilder.build(this.qb, entity, path, where)
@@ -76,11 +76,9 @@ export class SelectBuilder {
 			}
 			this.qb = this.qb.limit(input.args.limit, input.args.offset)
 		}
-
-		await promise
 	}
 
-	private async selectInternal(mapper: Mapper, entity: Model.Entity, path: Path, input: ObjectNode) {
+	private selectInternal(mapper: Mapper, entity: Model.Entity, path: Path, input: ObjectNode) {
 		if (!input.fields.find(it => it.name === entity.primary && it.alias === entity.primary)) {
 			input = input.withField(new FieldNode(entity.primary, entity.primary, {}))
 		}

package/src/mapper/select/WhereBuilder.ts

@@ -101,6 +101,7 @@ export class WhereBuilder {
 							conditionBuilder,
 							tableName,
 							relation.joiningColumn.columnName,
+							(targetEntity.fields[targetEntity.primary] as Model.AnyColumn).columnType,
 							primaryCondition,
 						)
 					}
@@ -114,7 +115,7 @@ export class WhereBuilder {
 			conditionBuilder = acceptFieldVisitor<SqlConditionBuilder>(this.schema, entity, fieldName, {
 				visitColumn: (entity, column) => {
 					const subWhere: Input.Condition<Input.ColumnValue> = where[column.name] as Input.Condition<Input.ColumnValue>
-					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, subWhere)
+					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, column.columnType, subWhere)
 				},
 				visitOneHasOneInverse: joinedWhere,
 				visitOneHasOneOwning: joinedWhere,
@@ -198,8 +199,10 @@ export class WhereBuilder {
 			.select(['junction_', fromColumn])
 		const primaryCondition = this.transformWhereToPrimaryCondition(relationWhere, targetEntity.primary)
 		if (primaryCondition !== null) {
+			const columnType = (targetEntity.fields[targetEntity.primary] as Model.AnyColumn).columnType
+
 			return augmentedBuilder.where(condition =>
-				this.conditionBuilder.build(condition, 'junction_', toColumn, primaryCondition),
+				this.conditionBuilder.build(condition, 'junction_', toColumn, columnType, primaryCondition),
 			)
 		}
 

package/tests/cases/integration/graphQlRequests/query/filter/manyHasManyOwnerRelation.test.ts

@@ -104,4 +104,5 @@ test('Post by category ids (where many has many owning)', async () => {
 		},
 	})
 })
+
 test.run()

package/tests/cases/integration/graphQlRequests/query/relations/oneHasMany.test.ts

@@ -416,4 +416,93 @@ test('Posts with paginated comments without count (one has many)', async () => {
 	})
 })
 
+
+test('Posts with paginated comments (one has many)', async () => {
+	await execute({
+		schema: new SchemaBuilder()
+			.entity('Post', entity => entity.oneHasMany('comments', relation => relation.target('Comment').ownedBy('post')))
+			.entity('Comment', entity => entity.column('content').column('deletedAt', c => c.type(Model.ColumnType.DateTime)))
+			.buildSchema(),
+		query: GQL`
+        query {
+          listPost {
+            id
+            comments: paginateComments(filter: {deletedAt: {isNull: true}}, first: 1) {
+				pages: pageInfo {
+					count: totalCount
+				}
+				comments: edges {
+					comment: node {
+						content
+					}
+				}
+            }
+          }
+        }
+			`,
+		executes: [
+			{
+				sql: SQL`select
+                       "root_"."id" as "root_id",
+                       "root_"."id" as "root_id"
+                     from "public"."post" as "root_"`,
+				response: {
+					rows: [{ root_id: testUuid(1) }],
+				},
+			},
+			{
+				sql: SQL`select
+       				count(*) as "row_count", "root_"."post_id"
+					from "public"."comment" as "root_"
+					where "root_"."deleted_at" is null and "root_"."post_id" in (?)
+					group by "root_"."post_id"`,
+				parameters: [testUuid(1)],
+				response: {
+					rows: [
+						{ post_id: testUuid(1), row_count: 5 },
+					],
+				},
+			},
+			{
+				sql: SQL`with "data" as
+    				(select
+    				    "root_"."post_id" as "__grouping_key",
+    				    "root_"."content" as "root_content",
+    					"root_"."id" as "root_id",
+    				    row_number() over(partition by  "root_"."post_id" order by "root_"."id" asc) as "rowNumber_"
+    					from "public"."comment" as "root_"
+    					where "root_"."deleted_at" is null
+    					      and "root_"."post_id" in (?)
+    					order by "root_"."id" asc)
+					select "data".*  from "data"   where "data"."rowNumber_" <= ?`,
+				parameters: [testUuid(1), 1],
+				response: {
+					rows: [
+						{ __grouping_key: testUuid(1), root_id: testUuid(3), root_content: 'Lorem ipsum' },
+					],
+				},
+			},
+		],
+		return: {
+			data: {
+				listPost: [
+					{
+						id: testUuid(1),
+						comments: {
+							pages: {
+								count: 5,
+							},
+							comments: [
+								{
+									comment: { content: 'Lorem ipsum' },
+								},
+							],
+						},
+					},
+				],
+			},
+		},
+	})
+})
+
 test.run()