@contember/engine-content-api 1.2.0-alpha.8 → 1.2.0-beta.1

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

@@ -0,0 +1,148 @@
+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')
+		tags = def.manyHasMany(Tag)
+	}
+
+	export class Tag {
+		name = def.stringColumn()
+	}
+}
+
+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, schema.settings.useExistsInHasManyFilter === true)
+
+	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 "root_articles"  where "root_"."id" = "root_articles"."author_id" and "root_articles"."is_public" = ?) and exists (select 1  from "__SCHEMA__"."article" as "root_articles"  where "root_"."id" = "root_articles"."author_id" and "root_articles"."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 "root_articles"  where "root_"."id" = "root_articles"."author_id" and "root_articles"."is_public" = ? and "root_articles"."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 "root_articles_tmp_" left join  "__SCHEMA__"."article" as "root_articles" on  "root_articles_tmp_"."id" = "root_articles"."author_id"  where "root_articles"."id" is null)',
+		)
+	})
+
+	it('where with nested has-many', () => {
+		const schema: Schema = { ...createSchema(WhereBuilderModel), settings: { useExistsInHasManyFilter: true } }
+		const where = createWhere(schema, {
+			articles: {
+				and: [
+					{ tags: { name: { eq: 'Hello' } } },
+					{ tags: { name: { eq: 'World' } } },
+				],
+			},
+		})
+		compareWhere(
+			where,
+			`where exists (select 1
+				from "__SCHEMA__"."article" as "root_articles"
+				where "root_"."id" = "root_articles"."author_id"
+					and exists (select 1
+						from "__SCHEMA__"."article_tags" as "root_articles_tags_junction_"
+						inner join  "__SCHEMA__"."tag" as "root_articles_tags" on  "root_articles_tags_junction_"."tag_id" = "root_articles_tags"."id"
+						where "root_articles"."id" = "root_articles_tags_junction_"."article_id" and "root_articles_tags"."name" = ?)
+					and exists (select 1
+						from "__SCHEMA__"."article_tags" as "root_articles_tags_junction_"
+						inner join  "__SCHEMA__"."tag" as "root_articles_tags" on  "root_articles_tags_junction_"."tag_id" = "root_articles_tags"."id"
+						where "root_articles"."id" = "root_articles_tags_junction_"."article_id" and "root_articles_tags"."name" = ?))`,
+		)
+	})
+
+
+	it('where without nested has-many', () => {
+		const schema: Schema = { ...createSchema(WhereBuilderModel) }
+		const where = createWhere(schema, {
+			articles: {
+				and: [
+					{ tags: { name: { eq: 'Hello' } } },
+					{ tags: { name: { eq: 'World' } } },
+				],
+			},
+		})
+		compareWhere(
+			where,
+			`where exists (select 1
+				from "__SCHEMA__"."article" as "root_articles"
+				left join "__SCHEMA__"."article_tags" as "root_articles_x_root_articles_tags" on "root_articles"."id" = "root_articles_x_root_articles_tags"."article_id"
+				left join "__SCHEMA__"."tag" as "root_articles_tags" on "root_articles_x_root_articles_tags"."tag_id" = "root_articles_tags"."id"
+				where "root_"."id" = "root_articles"."author_id" and "root_articles_tags"."name" = ? and "root_articles_tags"."name" = ?)`,
+		)
+	})
+})
+
+
+const compareWhere = (actual: string, expected: string) => {
+	const normalize = (s: string) => s.replaceAll(/\s+/g, ' ').trim()
+	try {
+		assert.equal(normalize(actual), normalize(expected))
+	} catch (e) {
+		console.log(normalize(actual))
+		console.log(normalize(expected))
+		throw e
+	}
+}

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

@@ -2,18 +2,21 @@ import { describe, it, assert } from 'vitest'
 import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
 import { SchemaDefinition as def } from '@contember/schema-definition'
 import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
+import { acceptFieldVisitor } from '@contember/schema-utils'
 
 namespace TestModel {
 	export class Author {
 		name = def.stringColumn()
 		isPublic = def.boolColumn().notNull()
 		image = def.manyHasOne(Image, 'authors')
+		articles = def.oneHasMany(Article, 'author')
 	}
 
 	export class Article {
 		title = def.stringColumn()
 		isPublic = def.boolColumn().notNull()
 		image = def.manyHasOne(Image, 'articles')
+		author = def.manyHasOne(Author, 'articles')
 	}
 
 	export class Image {
@@ -74,4 +77,216 @@ describe('where optimized', () => {
 			},
 		})
 	})
+
+	it('keep never', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{
+					or: [
+						{ url: { never: true } },
+						{ url: { never: true } },
+					],
+				},
+			],
+		}, model.entities.Image), {
+			id: { never: true },
+		},
+		)
+	})
+
+
+	const A = { authors: { isPublic: { eq: true } } }
+	const B = { authors: { name: { eq: 'John' } } }
+	const C = { authors: { name: { eq: 'Jack' } } }
+
+	it('minimize: A || (A && B) => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				A,
+				{ and: [A, B] },
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: (A && B) || A => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{ and: [A, B] },
+				A,
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: A && (A || B) => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				A,
+				{ or: [A, B] },
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: (A || B) && A => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{ or: [A, B] },
+				A,
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: A && (!A || B) => A && B', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				A,
+				{ or: [{ not: A }, B] },
+			],
+		}, model.entities.Image), { and: [A, B] })
+	})
+
+	it('minimize: A || (!A && B) => A || B', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				A,
+				{ and: [{ not: A }, B] },
+			],
+		}, model.entities.Image), { or: [A, B] })
+	})
+
+
+	it('minimize: A || !A => 1', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				A,
+				{ not: A },
+			],
+		}, model.entities.Image), { id: { always: true } })
+	})
+
+	it('minimize: A && !A => 0', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				A,
+				{ not: A },
+			],
+		}, model.entities.Image), { id: { never: true } })
+	})
+
+	it('minimize: !A && !A => !A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{ not: A },
+				{ not: A },
+			],
+		}, model.entities.Image), { not: A })
+	})
+
+
+	it('not minimize: (A && B) || (A && C)', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{ and: [A, B] },
+				{ and: [A, C] },
+			],
+		}, model.entities.Image), {
+			or: [
+				{ and: [A, B] },
+				{ and: [A, C] },
+			],
+		})
+	})
+
+
+	describe('remove id predicates', () => {
+
+		it('remove ID predicate when traversing from a relation - always', () => {
+			const relationPath = [acceptFieldVisitor(model, 'Image', 'authors', {
+				visitColumn: () => {
+					throw new Error()
+				},
+				visitRelation: context => context,
+			})]
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				image: { id: { isNull: false } },
+			}, model.entities.Author, { relationPath }), {
+				id: { always: true },
+			})
+		})
+
+
+		it('remove ID predicate when traversing from a relation - never', () => {
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				image: { id: { isNull: true } },
+			}, model.entities.Author, { relationPath: [acceptFieldVisitor(model, 'Image', 'authors', {
+				visitColumn: () => {
+					throw new Error()
+				},
+				visitRelation: context => context,
+			})] }), {
+				id: { never: true },
+			})
+		})
+
+		it('remove ID predicate when traversing in where', () => {
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				authors: { image: { id: { isNull: false } } },
+			}, model.entities.Image), {
+				id: { always: true },
+			})
+		})
+
+		it('do not remove ID predicate when traversing from a has-many relation', () => {
+			const relationPath = [acceptFieldVisitor(model, 'Author', 'image', {
+				visitColumn: () => {
+					throw new Error()
+				},
+				visitRelation: context => context,
+			})]
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				authors: { id: { isNull: false } },
+			}, model.entities.Image, { relationPath }), {
+				authors: { id: { isNull: false } },
+			})
+		})
+
+		it('do not remove ID predicate when traversing from a nested has-many relation', () => {
+			const relationPath = [
+				acceptFieldVisitor(model, 'Author', 'articles', {
+					visitColumn: () => {
+						throw new Error()
+					},
+					visitRelation: context => context,
+				}),
+				acceptFieldVisitor(model, 'Article', 'image', {
+					visitColumn: () => {
+						throw new Error()
+					},
+					visitRelation: context => context,
+				}),
+			]
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				articles: { author: { id: { isNull: false } } },
+			}, model.entities.Image, { relationPath }), {
+				articles: { author: { id: { isNull: false } } },
+			})
+		})
+
+		it('do not remove ID predicate when traversing in where over has-many relation', () => {
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				image: { authors: { id: { isNull: false } } },
+			}, model.entities.Author), {
+				image: { authors: { id: { isNull: false } } },
+			})
+		})
+
+
+		it('do not remove ID predicate when traversing in where over has-many relation - nested', () => {
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				image: { authors: { image: { id: { isNull: false } } } },
+			}, model.entities.Author), {
+				image: { authors: { image: { id: { isNull: false } } } },
+			})
+		})
+	})
 })
+

package/tests/src/test.ts

@@ -1,11 +1,11 @@
 import { Acl, Model, Schema, Validation } from '@contember/schema'
-import { ExecutionContainerFactory, GraphQlSchemaBuilderFactory, Authorizator } from '../../src'
+import { Authorizator, ExecutionContainerFactory, GraphQlSchemaBuilderFactory } from '../../src'
 import { AllowAllPermissionFactory, emptySchema } from '@contember/schema-utils'
 import { executeGraphQlTest } from './testGraphql'
 import { Client } from '@contember/database'
 import { createConnectionMock } from '@contember/database-tester'
 import { createUuidGenerator } from '@contember/engine-api-tester'
-import { getArgumentValues } from 'graphql/execution/values'
+import { getArgumentValues } from 'graphql'
 import { SQL } from './tags'
 
 export interface SqlQuery {

package/tests/src/testGraphql.ts

@@ -1,3 +1,4 @@
+import { NullLoggerHandler, withLogger, createLogger } from '@contember/logger'
 import { graphql, GraphQLSchema } from 'graphql'
 import { assert } from 'vitest'
 
@@ -10,11 +11,14 @@ export interface Test {
 }
 
 export const executeGraphQlTest = async (test: Test) => {
-	const rawResponse = await graphql({
-		schema: test.schema,
-		source: test.query,
-		contextValue: test.context,
-		variableValues: test.queryVariables,
+	const logger = createLogger(new NullLoggerHandler())
+	const rawResponse = await withLogger(logger, () => {
+		return graphql({
+			schema: test.schema,
+			source: test.query,
+			contextValue: test.context,
+			variableValues: test.queryVariables,
+		})
 	})
 	const response = JSON.parse(JSON.stringify(rawResponse))
 	if ('errors' in rawResponse) {

package/dist/src/inputProcessing/InputContext.d.ts

@@ -1,43 +0,0 @@
-import { Input, Model } from '@contember/schema';
-export interface ColumnContext {
-    entity: Model.Entity;
-    column: Model.AnyColumn;
-    input: Input.ColumnValue | undefined;
-}
-export interface ManyHasManyInverseContext {
-    entity: Model.Entity;
-    relation: Model.ManyHasManyInverseRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.ManyHasManyOwningRelation;
-}
-export interface ManyHasManyOwningContext {
-    entity: Model.Entity;
-    relation: Model.ManyHasManyOwningRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.ManyHasManyInverseRelation | null;
-}
-export interface ManyHasOneContext {
-    entity: Model.Entity;
-    relation: Model.ManyHasOneRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.OneHasManyRelation | null;
-}
-export interface OneHasManyContext {
-    entity: Model.Entity;
-    relation: Model.OneHasManyRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.ManyHasOneRelation;
-}
-export interface OneHasOneInverseContext {
-    entity: Model.Entity;
-    relation: Model.OneHasOneInverseRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.OneHasOneOwningRelation;
-}
-export interface OneHasOneOwningContext {
-    entity: Model.Entity;
-    relation: Model.OneHasOneOwningRelation;
-    targetEntity: Model.Entity;
-    targetRelation: Model.OneHasOneInverseRelation | null;
-}
-//# sourceMappingURL=InputContext.d.ts.map

package/dist/src/inputProcessing/InputContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InputContext.d.ts","sourceRoot":"","sources":["../../../src/inputProcessing/InputContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEhD,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,MAAM,EAAE,KAAK,CAAC,SAAS,CAAA;IACvB,KAAK,EAAE,KAAK,CAAC,WAAW,GAAG,SAAS,CAAA;CACpC;AAED,MAAM,WAAW,yBAAyB;IACzC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,0BAA0B,CAAA;IAC1C,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,yBAAyB,CAAA;CAC/C;AAED,MAAM,WAAW,wBAAwB;IACxC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,yBAAyB,CAAA;IACzC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,0BAA0B,GAAG,IAAI,CAAA;CACvD;AAED,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,kBAAkB,CAAA;IAClC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,kBAAkB,GAAG,IAAI,CAAA;CAC/C;AAED,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,kBAAkB,CAAA;IAClC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,kBAAkB,CAAA;CACxC;AAED,MAAM,WAAW,uBAAuB;IACvC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,wBAAwB,CAAA;IACxC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,uBAAuB,CAAA;CAC7C;AAED,MAAM,WAAW,sBAAsB;IACtC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,QAAQ,EAAE,KAAK,CAAC,uBAAuB,CAAA;IACvC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;IAC1B,cAAc,EAAE,KAAK,CAAC,wBAAwB,GAAG,IAAI,CAAA;CACrD"}

package/dist/src/inputProcessing/InputContext.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=InputContext.js.map

package/dist/src/inputProcessing/InputContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"InputContext.js","sourceRoot":"","sources":["../../../src/inputProcessing/InputContext.ts"],"names":[],"mappings":""}

package/src/inputProcessing/InputContext.ts

@@ -1,49 +0,0 @@
-import { Input, Model } from '@contember/schema'
-
-export interface ColumnContext {
-	entity: Model.Entity
-	column: Model.AnyColumn
-	input: Input.ColumnValue | undefined
-}
-
-export interface ManyHasManyInverseContext {
-	entity: Model.Entity
-	relation: Model.ManyHasManyInverseRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.ManyHasManyOwningRelation
-}
-
-export interface ManyHasManyOwningContext {
-	entity: Model.Entity
-	relation: Model.ManyHasManyOwningRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.ManyHasManyInverseRelation | null
-}
-
-export interface ManyHasOneContext {
-	entity: Model.Entity
-	relation: Model.ManyHasOneRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.OneHasManyRelation | null
-}
-
-export interface OneHasManyContext {
-	entity: Model.Entity
-	relation: Model.OneHasManyRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.ManyHasOneRelation
-}
-
-export interface OneHasOneInverseContext {
-	entity: Model.Entity
-	relation: Model.OneHasOneInverseRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.OneHasOneOwningRelation
-}
-
-export interface OneHasOneOwningContext {
-	entity: Model.Entity
-	relation: Model.OneHasOneOwningRelation
-	targetEntity: Model.Entity
-	targetRelation: Model.OneHasOneInverseRelation | null
-}