@contember/engine-content-api 1.2.0-beta.3 → 1.2.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.2.0-beta.3",
+  "version": "1.2.0-rc.2",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,31 +10,31 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.2.0-beta.3",
-    "@contember/dic": "^1.2.0-beta.3",
-    "@contember/logger": "^1.2.0-beta.3",
-    "@contember/graphql-utils": "^1.2.0-beta.3",
-    "@contember/schema": "^1.2.0-beta.3",
-    "@contember/schema-definition": "^1.2.0-beta.3",
-    "@contember/schema-utils": "^1.2.0-beta.3",
+    "@contember/database": "^1.2.0-rc.2",
+    "@contember/dic": "^1.2.0-rc.2",
+    "@contember/logger": "^1.2.0-rc.2",
+    "@contember/graphql-utils": "^1.2.0-rc.2",
+    "@contember/schema": "^1.2.0-rc.2",
+    "@contember/schema-definition": "^1.2.0-rc.2",
+    "@contember/schema-utils": "^1.2.0-rc.2",
     "@graphql-tools/schema": "^8.3.5",
     "fast-deep-equal": "^3.1.3",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.2.0-beta.3",
-    "@contember/engine-api-tester": "^1.2.0-beta.3",
-    "@contember/schema-definition": "^1.2.0-beta.3",
+    "@contember/database-tester": "^1.2.0-rc.2",
+    "@contember/engine-api-tester": "^1.2.0-rc.2",
+    "@contember/schema-definition": "^1.2.0-rc.2",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",
     "@graphql-codegen/typescript-resolvers": "^2.6.6",
     "@types/node": "^18",
     "graphql": "^16.5.0",
-    "pg": "^8.5.0"
+    "pg": "^8.9.0"
   },
   "peerDependencies": {
     "graphql": ">= 14.6.0",
-    "pg": "^8.5.0"
+    "pg": "^8.9.0"
   }
 }

package/src/acl/PredicatesInjector.ts

@@ -54,7 +54,13 @@ export class PredicatesInjector {
 		for (let field of fields) {
 			resultWhere[field] = acceptFieldVisitor(this.schema, entity, field, {
 				visitColumn: () => where[field],
-				visitRelation: context => this.injectToWhere(where[field] as Input.Where, context.targetEntity, false, context),
+				visitRelation: context => {
+					const relationWhere = where[field] as Input.OptionalWhere | null
+					if (relationWhere === null) {
+						return null
+					}
+					return this.injectToWhere(relationWhere, context.targetEntity, false, context)
+				},
 			})
 		}
 		const fieldsForPredicate = !isRoot

package/src/acl/VariableInjector.ts

@@ -2,12 +2,18 @@ import { Acl, Input, Model } from '@contember/schema'
 import { PredicateDefinitionProcessor } from '@contember/schema-utils'
 
 export class VariableInjector {
+	private injectorCache = new WeakMap<Acl.PredicateDefinition, Input.Where>()
+
 	constructor(private readonly schema: Model.Schema, private readonly variables: Acl.VariablesMap) {}
 
 	public inject(entity: Model.Entity, where: Acl.PredicateDefinition): Input.Where {
+		const cacheEntry = this.injectorCache.get(where)
+		if (cacheEntry !== undefined) {
+			return cacheEntry
+		}
 		const predicateDefinitionProcessor = new PredicateDefinitionProcessor(this.schema)
 
-		return predicateDefinitionProcessor.process(entity, where, {
+		const resultWhere = predicateDefinitionProcessor.process(entity, where, {
 			handleColumn: ({ value }) => {
 				if (typeof value === 'string') {
 					return this.variables[value] ?? { never: true }
@@ -21,5 +27,7 @@ export class VariableInjector {
 				return value
 			},
 		})
+		this.injectorCache.set(where, resultWhere)
+		return resultWhere
 	}
 }

package/src/mapper/select/ConditionBuilder.ts

@@ -8,8 +8,11 @@ export class ConditionBuilder {
 		tableName: string,
 		columnName: string,
 		columnType: string,
-		condition: Input.Condition<any>,
+		condition: Input.Condition<any> | null,
 	): SqlConditionBuilder {
+		if (condition === null) {
+			return builder
+		}
 		const entries = Object.entries(condition)
 			.filter(<T extends keyof Input.Condition>(it: [string, any]): it is [T, Input.Condition[T]] =>
 				it[1] !== null,

package/src/mapper/select/WhereBuilder.ts

@@ -87,7 +87,7 @@ export class WhereBuilder {
 	): SqlConditionBuilder {
 		const tableName = path.alias
 
-		if (where.and !== undefined && where.and.length > 0) {
+		if (where.and !== undefined && where.and !== null && where.and.length > 0) {
 			const expr = where.and
 			conditionBuilder = conditionBuilder.and(clause =>
 				expr.reduce(
@@ -104,7 +104,7 @@ export class WhereBuilder {
 				),
 			)
 		}
-		if (where.or !== undefined && where.or.length > 0) {
+		if (where.or !== undefined && where.or !== null && where.or.length > 0) {
 			const expr = where.or
 			conditionBuilder = conditionBuilder.or(clause =>
 				expr.reduce(
@@ -123,7 +123,7 @@ export class WhereBuilder {
 				),
 			)
 		}
-		if (where.not !== undefined) {
+		if (where.not !== undefined && where.not !== null) {
 			const expr = where.not
 			conditionBuilder = conditionBuilder.not(clause =>
 				this.buildRecursive({
@@ -141,12 +141,16 @@ export class WhereBuilder {
 			if (fieldName === 'and' || fieldName === 'or' || fieldName === 'not') {
 				continue
 			}
+			const fieldWhere = where[fieldName]
+			if (!fieldWhere) {
+				continue
+			}
 
 			const targetPath = path.for(fieldName)
 
 			const joinedWhere = ({ targetEntity, relation, entity }: Model.AnyRelationContext): SqlConditionBuilder => {
-				const relationWhere = where[fieldName] as Input.Where
-				if (Object.keys(relationWhere).length === 0) {
+				const relationWhere = where[fieldName] as Input.OptionalWhere | null
+				if (!relationWhere || Object.keys(relationWhere).length === 0) {
 					return conditionBuilder
 				}
 				if (isIt<Model.JoiningColumnRelation>(relation, 'joiningColumn')) {
@@ -174,10 +178,11 @@ 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, column.columnType, subWhere)
+					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, column.columnType, fieldWhere as Input.Condition<Input.ColumnValue>)
 				},
 				visitOneHasOneInverse: joinedWhere,
 				visitOneHasOneOwning: joinedWhere,
@@ -187,12 +192,10 @@ export class WhereBuilder {
 						return joinedWhere(context)
 					}
 
-					const relationWhere = where[fieldName] as Input.Where
-
 					return conditionBuilder.exists(
 						this.createManyHasManySubquery(
 							[tableName, entity.primaryColumn],
-							relationWhere,
+							fieldWhere as Input.OptionalWhere,
 							context.targetEntity,
 							context.targetRelation.joiningTable,
 							'inverse',
@@ -205,12 +208,12 @@ export class WhereBuilder {
 						return joinedWhere(context)
 					}
 
-					const relationWhere = where[fieldName] as Input.Where
+					const relationWhere = where[fieldName] as Input.Where | null
 
 					return conditionBuilder.exists(
 						this.createManyHasManySubquery(
 							[tableName, entity.primaryColumn],
-							relationWhere,
+							fieldWhere as Input.OptionalWhere,
 							context.targetEntity,
 							context.relation.joiningTable,
 							'owning',
@@ -223,7 +226,7 @@ export class WhereBuilder {
 						return joinedWhere(context)
 					}
 
-					const relationWhere = where[fieldName] as Input.Where
+					const relationWhere = fieldWhere as Input.OptionalWhere
 
 					const qb = this.hasRootIsNull(relationWhere, context.targetEntity)
 						? SelectBuilder.create()
@@ -255,7 +258,7 @@ export class WhereBuilder {
 
 	private createManyHasManySubquery(
 		outerColumn: QueryBuilder.ColumnIdentifier,
-		relationWhere: Input.Where,
+		relationWhere: Input.OptionalWhere,
 		targetEntity: Model.Entity,
 		joiningTable: Model.JoiningTable,
 		fromSide: 'owning' | 'inverse',
@@ -291,7 +294,7 @@ export class WhereBuilder {
 		})
 	}
 
-	private transformWhereToPrimaryCondition(where: Input.Where, primaryField: string): Input.Condition<never> | null {
+	private transformWhereToPrimaryCondition(where: Input.OptionalWhere, primaryField: string): Input.Condition<never> | null {
 		const keys = Object.keys(where)
 		if (keys.filter(it => !['and', 'or', 'not', primaryField].includes(it)).length > 0) {
 			return null
@@ -335,10 +338,10 @@ export class WhereBuilder {
 		return condition
 	}
 
-	private hasRootIsNull(where: Input.Where, entity: Model.Entity): boolean {
+	private hasRootIsNull(where: Input.OptionalWhere, entity: Model.Entity): boolean {
 		for (const key in where) {
 			if (key === 'and' || key === 'or') {
-				if (where[key]?.some(it => this.hasRootIsNull(it, entity))) {
+				if (where[key]?.some(it => it && this.hasRootIsNull(it, entity))) {
 					return true
 				}
 			} else if (key === 'not') {

package/src/mapper/select/optimizer/helpers.ts

@@ -47,11 +47,11 @@ export const optimizeAnd = <P extends Record<string, unknown>>(operands: readonl
 	}
 }
 
-export const optimizeNot = <P extends Record<string, unknown>>(operand: P | boolean): P['not'] | { not: P } | boolean => {
+export const optimizeNot = <P extends Record<string, unknown>>(operand: P | boolean): Exclude<P['not'] | { not: P } | boolean, null | undefined> => {
 	if (typeof operand === 'boolean') {
 		return !operand
 	} else if (operand.not) {
-		return operand.not as P['not']
+		return operand.not as Exclude<P['not'], null | undefined>
 	} else {
 		return { not: operand }
 	}

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

@@ -1,11 +1,11 @@
 import { PermissionFactory, PredicateFactory, PredicatesInjector, VariableInjector } from '../../../src/acl'
-import { SchemaBuilder, SchemaDefinition as def, AclDefinition as acl, createSchema } from '@contember/schema-definition'
+import { SchemaBuilder, SchemaDefinition as def, AclDefinition as acl, createSchema, PermissionsBuilder } from '@contember/schema-definition'
 import { Acl, Model } from '@contember/schema'
 import { describe, it, assert } from 'vitest'
 import { PermissionsFactory } from '@contember/engine-system-api/dist/src/model'
 import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
 import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
-import { acceptFieldVisitor } from '@contember/schema-utils'
+import { acceptFieldVisitor, AllowAllPermissionFactory } from '@contember/schema-utils'
 import { testUuid } from '@contember/engine-api-tester'
 
 
@@ -204,3 +204,27 @@ describe('predicates injector elimination', () => {
 		})
 	})
 })
+
+describe('predicate injector input handling', () => {
+	const schema = createSchema(DeepFilterModel)
+	const permissions = new AllowAllPermissionFactory().create(schema.model)
+	const injector = new PredicatesInjector(
+		schema.model,
+		new PredicateFactory(permissions, schema.model, new VariableInjector(schema.model, {})),
+	)
+	it('handles null', () => {
+		injector.inject(schema.model.entities.ImageUse, {
+			image: null,
+			articles: {
+				and: [
+					null,
+					{
+						title: null,
+					},
+				],
+				not: null,
+				or: null,
+			},
+		})
+	})
+})

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

@@ -25,7 +25,7 @@ namespace WhereBuilderModel {
 	}
 }
 
-const createWhere = (schema: Schema, where: Input.Where) => {
+const createWhere = (schema: Schema, where: Input.OptionalWhere) => {
 	const pathFactory = new PathFactory()
 	const joinBuilder = new JoinBuilder(schema.model)
 	const conditionBuilder = new ConditionBuilder()
@@ -133,6 +133,26 @@ describe('where builder', () => {
 				where "root_"."id" = "root_articles"."author_id" and "root_articles_tags"."name" = ? and "root_articles_tags"."name" = ?)`,
 		)
 	})
+
+
+	it('handles nulls', () => {
+		const schema: Schema = { ...createSchema(WhereBuilderModel) }
+		const where = createWhere(schema, {
+			name: null,
+			articles: {
+				and: [
+					null,
+					{ and: null },
+					{ tags: null },
+				],
+				not: null,
+			},
+		})
+		compareWhere(
+			where,
+			`where exists (select 1 from "__SCHEMA__"."article" as "root_articles" where "root_"."id" = "root_articles"."author_id")`,
+		)
+	})
 })