@contember/engine-content-api 1.2.0-alpha.11 → 1.2.0-alpha.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.2.0-alpha.11",
+  "version": "1.2.0-alpha.12",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,19 +10,19 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.2.0-alpha.11",
-    "@contember/dic": "^1.2.0-alpha.11",
-    "@contember/engine-common": "^1.2.0-alpha.11",
-    "@contember/graphql-utils": "^1.2.0-alpha.11",
-    "@contember/schema": "^1.2.0-alpha.11",
-    "@contember/schema-utils": "^1.2.0-alpha.11",
+    "@contember/database": "^1.2.0-alpha.12",
+    "@contember/dic": "^1.2.0-alpha.12",
+    "@contember/engine-common": "^1.2.0-alpha.12",
+    "@contember/graphql-utils": "^1.2.0-alpha.12",
+    "@contember/schema": "^1.2.0-alpha.12",
+    "@contember/schema-utils": "^1.2.0-alpha.12",
     "@graphql-tools/schema": "^8.3.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.2.0-alpha.11",
-    "@contember/engine-api-tester": "^1.2.0-alpha.11",
-    "@contember/schema-definition": "^1.2.0-alpha.11",
+    "@contember/database-tester": "^1.2.0-alpha.12",
+    "@contember/engine-api-tester": "^1.2.0-alpha.12",
+    "@contember/schema-definition": "^1.2.0-alpha.12",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/mapper/select/WhereBuilder.ts

@@ -1,10 +1,16 @@
 import { isIt } from '../../utils'
-import { acceptFieldVisitor } from '@contember/schema-utils'
+import { acceptFieldVisitor, isColumn } from '@contember/schema-utils'
 import { Input, Model } from '@contember/schema'
 import { Path, PathFactory } from './Path'
 import { JoinBuilder } from './JoinBuilder'
 import { ConditionBuilder } from './ConditionBuilder'
-import { ConditionBuilder as SqlConditionBuilder, Operator, QueryBuilder, SelectBuilder } from '@contember/database'
+import {
+	ConditionBuilder as SqlConditionBuilder,
+	Literal,
+	Operator,
+	QueryBuilder,
+	SelectBuilder, wrapIdentifier,
+} from '@contember/database'
 import { WhereOptimizer } from './optimizer/WhereOptimizer'
 
 export class WhereBuilder {
@@ -172,10 +178,17 @@ export class WhereBuilder {
 
 					const relationWhere = where[fieldName] as Input.Where
 
-					const qb = SelectBuilder.create()
-						.select(it => it.raw('1'))
-						.from(context.targetEntity.tableName, 'sub_')
-						.where(it => it.columnsEq([tableName, entity.primaryColumn], ['sub_', context.targetRelation.joiningColumn.columnName]))
+					const qb = this.hasRootIsNull(relationWhere, context.targetEntity)
+						? SelectBuilder.create()
+							.select(it => it.raw('1'))
+							.from(new Literal(`(select ${wrapIdentifier(tableName)}.${wrapIdentifier(entity.primaryColumn)})`), 'sub2_')
+							.leftJoin(context.targetEntity.tableName, 'sub_', it =>
+								it.columnsEq(['sub2_', entity.primaryColumn], ['sub_', context.targetRelation.joiningColumn.columnName]),
+							)
+						: SelectBuilder.create()
+							.select(it => it.raw('1'))
+							.from(context.targetEntity.tableName, 'sub_')
+							.where(it => it.columnsEq([tableName, entity.primaryColumn], ['sub_', context.targetRelation.joiningColumn.columnName]))
 
 					return conditionBuilder.exists(
 						this.buildInternal(
@@ -192,6 +205,7 @@ export class WhereBuilder {
 		return conditionBuilder
 	}
 
+
 	private createManyHasManySubquery(
 		outerColumn: QueryBuilder.ColumnIdentifier,
 		relationWhere: Input.Where,
@@ -271,6 +285,39 @@ export class WhereBuilder {
 		}
 		return condition
 	}
+
+	private hasRootIsNull(where: Input.Where, entity: Model.Entity): boolean {
+		for (const key in where) {
+			if (key === 'and' || key === 'or') {
+				if (where[key]?.some(it => this.hasRootIsNull(it, entity))) {
+					return true
+				}
+			} else if (key === 'not') {
+				if (where.not && this.hasRootIsNull(where.not, entity)) {
+					return true
+				}
+			} else if (isColumn(entity.fields[key]) && this.conditionHasIsNull(where[key] as Input.Condition)) {
+				return true
+			}
+		}
+		return false
+	}
+
+	private conditionHasIsNull(cond: Input.Condition): boolean {
+		if (cond.isNull !== undefined) {
+			return true
+		}
+		if (cond.and && cond.and.some(it => this.conditionHasIsNull(it))) {
+			return true
+		}
+		if (cond.or && cond.or.some(it => this.conditionHasIsNull(it))) {
+			return true
+		}
+		if (cond.not && this.conditionHasIsNull(cond.not)) {
+			return true
+		}
+		return false
+	}
 }
 
 export type WhereJoinDefinition = { path: Path; entity: Model.Entity; relationName: string }

package/tests/cases/unit/whereBuilder.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, assert } from 'vitest'
+import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
+import { ConditionBuilder, JoinBuilder, PathFactory, WhereBuilder } from '../../../src/mapper'
+import { Compiler, SelectBuilder } from '@contember/database'
+import { Input, Schema } from '@contember/schema'
+
+namespace WhereBuilderModel {
+	export class Author {
+		name = def.stringColumn()
+		isPublic = def.boolColumn().notNull()
+		articles = def.oneHasMany(Article, 'author')
+	}
+
+	export class Article {
+		title = def.stringColumn()
+		isPublic = def.boolColumn().notNull()
+		author = def.manyHasOne(Author, 'articles')
+	}
+}
+
+const createWhere = (schema: Schema, where: Input.Where) => {
+	const pathFactory = new PathFactory()
+	const joinBuilder = new JoinBuilder(schema.model)
+	const conditionBuilder = new ConditionBuilder()
+	const whereOptimizer = new WhereOptimizer(schema.model, new ConditionOptimizer())
+	const whereBuilder = new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimizer)
+
+	const qb = SelectBuilder.create()
+		.from('author', 'root_')
+
+	return whereBuilder.build(qb, schema.model.entities.Author, pathFactory.create([]), where).options.where.compile().sql
+}
+
+describe('where builder', () => {
+	it('where on has-many relation with AND outside', () => {
+		const schema = createSchema(WhereBuilderModel)
+		const where = createWhere(schema, {
+			and: [
+				{
+					articles: { isPublic: { eq: true } },
+				},
+				{
+					articles: { title: { eq: 'Hello' } },
+				},
+			],
+		})
+		assert.equal(
+			where,
+			' where exists (select 1  from "__SCHEMA__"."article" as "sub_"  where "root_"."id" = "sub_"."author_id" and "sub_"."is_public" = ?) and exists (select 1  from "__SCHEMA__"."article" as "sub_"  where "root_"."id" = "sub_"."author_id" and "sub_"."title" = ?)',
+		)
+	})
+
+	it('where on has-many relation with AND inside', () => {
+		const schema = createSchema(WhereBuilderModel)
+		const where = createWhere(schema, {
+			articles: {
+				and: [
+					{ isPublic: { eq: true } },
+					{ title: { eq: 'Hello' } },
+				],
+			},
+		})
+		assert.equal(
+			where,
+			' where exists (select 1  from "__SCHEMA__"."article" as "sub_"  where "root_"."id" = "sub_"."author_id" and "sub_"."is_public" = ? and "sub_"."title" = ?)',
+		)
+	})
+
+
+	it('where on has-many relation with isNull', () => {
+		const schema = createSchema(WhereBuilderModel)
+		const where = createWhere(schema, {
+			articles: {
+				id: { isNull: true },
+			},
+		})
+		assert.equal(
+			where,
+			' where exists (select 1  from (select "root_"."id") as "sub2_" left join  "__SCHEMA__"."article" as "sub_" on  "sub2_"."id" = "sub_"."author_id"  where "sub_"."id" is null)',
+		)
+	})
+})