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

package/src/mapper/select/RelationFetcher.ts

@@ -28,13 +28,12 @@ type FetchOneHasManyGroupsArgs = {
 	ids: Input.PrimaryValue[]
 }
 
-type ManyHasManyBaseArgs =
-	& {
-		mapper: Mapper
-		ids: Input.PrimaryValue[]
-		relationPath: Model.AnyRelationContext[]
-		relationContext: Model.ManyHasManyInverseContext | Model.ManyHasManyOwningContext
-	}
+type ManyHasManyBaseArgs = {
+	mapper: Mapper
+	ids: Input.PrimaryValue[]
+	relationPath: Model.AnyRelationContext[]
+	relationContext: Model.ManyHasManyInverseContext | Model.ManyHasManyOwningContext
+}
 type CountManyHasManyGroupArgs =
 	& ManyHasManyBaseArgs
 	& {
@@ -179,14 +178,18 @@ export class RelationFetcher {
 		return this.buildManyHasManyGroups(targetEntity, joiningColumns, result, junctionValues)
 	}
 
-	private resolveJoiningColumns({ relationType, joiningTable }: { joiningTable: Model.JoiningTable; relationType: 'manyHasManyOwning' | 'manyHasManyInverse' }): JoiningColumns {
-		return relationType === 'manyHasManyOwning' ? {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		} : {
-			sourceColumn: joiningTable.inverseJoiningColumn,
-			targetColumn: joiningTable.joiningColumn,
-		}
+	private resolveJoiningColumns(
+		{ relationType, joiningTable }: { joiningTable: Model.JoiningTable; relationType: 'manyHasManyOwning' | 'manyHasManyInverse' },
+	): JoiningColumns {
+		return relationType === 'manyHasManyOwning'
+			? {
+				sourceColumn: joiningTable.joiningColumn,
+				targetColumn: joiningTable.inverseJoiningColumn,
+			}
+			: {
+				sourceColumn: joiningTable.inverseJoiningColumn,
+				targetColumn: joiningTable.joiningColumn,
+			}
 	}
 
 	private buildManyHasManyGroups(
@@ -232,7 +235,7 @@ export class RelationFetcher {
 			['junction_', column.sourceColumn.columnName],
 			(orderable, qb) => {
 				if (object.args.orderBy) {
-					[qb, orderable] = this.orderBuilder.build(
+					;[qb, orderable] = this.orderBuilder.build(
 						qb,
 						orderable,
 						targetEntity,
@@ -268,19 +271,21 @@ export class RelationFetcher {
 
 		const where = this.predicateInjector.inject(targetEntity, objectArgs.filter || {}, relationPath[relationPath.length - 1])
 		const hasWhere = where && Object.keys(where).length > 0
-		const hasFieldOrderBy =
-			objectArgs.orderBy &&
-			objectArgs.orderBy.length > 0 &&
-			!objectArgs.orderBy[0]._random &&
-			objectArgs.orderBy[0]._randomSeeded === undefined
+		const hasFieldOrderBy = objectArgs.orderBy
+			&& objectArgs.orderBy.length > 0
+			&& !objectArgs.orderBy[0]._random
+			&& objectArgs.orderBy[0]._randomSeeded === undefined
 
 		if (hasWhere || hasFieldOrderBy) {
 			const path = this.pathFactory.create([])
-			qb = qb.join(targetEntity.tableName, path.alias, condition =>
-				condition.compareColumns(['junction_', column.targetColumn.columnName], Operator.eq, [
-					path.alias,
-					targetEntity.primaryColumn,
-				]),
+			qb = qb.join(
+				targetEntity.tableName,
+				path.alias,
+				condition =>
+					condition.compareColumns(['junction_', column.targetColumn.columnName], Operator.eq, [
+						path.alias,
+						targetEntity.primaryColumn,
+					]),
 			)
 		}
 

package/src/mapper/select/SelectBuilder.ts

@@ -66,7 +66,7 @@ export class SelectBuilder {
 				[path.alias, groupByColumn],
 				(orderable, qb) => {
 					if (orderBy.length > 0) {
-						[qb, orderable] = this.orderByBuilder.build(qb, orderable, entity, this.pathFactory.create([]), orderBy)
+						;[qb, orderable] = this.orderByBuilder.build(qb, orderable, entity, this.pathFactory.create([]), orderBy)
 					}
 					return [orderable, qb]
 				},
@@ -75,7 +75,7 @@ export class SelectBuilder {
 			)
 		} else {
 			if (orderBy.length > 0) {
-				[this.qb] = this.orderByBuilder.build(this.qb, null, entity, path, orderBy)
+				;[this.qb] = this.orderByBuilder.build(this.qb, null, entity, path, orderBy)
 			}
 			this.qb = this.qb.limit(input.args.limit, input.args.offset)
 		}
@@ -103,16 +103,15 @@ export class SelectBuilder {
 					entity,
 					path.back(),
 					fieldPredicate,
-					apply => this.qb.select(expr =>
-						expr.selectCondition(condition => {
-							condition = apply(condition)
-							if (condition.isEmpty()) {
-								return condition.raw('true')
-							}
-							return condition
-						}),
-					predicatePath.alias,
-					),
+					apply =>
+						this.qb.select(expr =>
+							expr.selectCondition(condition => {
+								condition = apply(condition)
+								if (condition.isEmpty()) {
+									return condition.raw('true')
+								}
+								return condition
+							}), predicatePath.alias),
 					{ relationPath: this.relationPath, evaluatedPredicates: [primaryPredicate] },
 				)
 				fetchedPredicates.add(predicate)
@@ -132,7 +131,6 @@ export class SelectBuilder {
 				return assertNever(field)
 			})()
 
-
 			const executionContext: SelectExecutionHandlerContext = {
 				mapper,
 				relationPath: this.relationPath,
@@ -198,7 +196,11 @@ export class SelectBuilder {
 		}
 	}
 
-	private async getColumnValues(columnPath: Path, columnName: string, predicateGetter: null | ColumnValueGetter<boolean>): Promise<Input.PrimaryValue[]> {
+	private async getColumnValues(
+		columnPath: Path,
+		columnName: string,
+		predicateGetter: null | ColumnValueGetter<boolean>,
+	): Promise<Input.PrimaryValue[]> {
 		this.qb = this.qb.select([columnPath.back().alias, columnName], columnPath.alias)
 		const rows = await this.rows
 		const filteredRows = predicateGetter === null ? rows : rows.filter(predicateGetter)

package/src/mapper/select/SelectExecutionHandler.ts

@@ -17,31 +17,33 @@ export type DataCallback = (ids: Input.PrimaryValue[]) => Promise<SelectNestedDa
 export type SelectExecutionHandlerContext<
 	FieldArgs = any,
 	FieldExtensions extends Record<string, any> = Record<string, any>,
-> = {
-	mapper: Mapper
-	path: Path
-	entity: Model.Entity
-	relationPath: Model.AnyRelationContext[]
-	addPredicate: (predicate: Acl.Predicate) => (row: SelectRow) => boolean
-	addColumn: (args: {
-		predicate?: Acl.Predicate
-		query?: (qb: SelectBuilder<SelectBuilder.Result>) => SelectBuilder<SelectBuilder.Result>
-		path?: Path
-		valueGetter?: ColumnValueGetter
-	}) => void
-	addData: (args: {
-		field: string
-		dataProvider: DataCallback
-		predicate?: Acl.Predicate
-		defaultValue?: SelectNestedDefaultValue
-	}) => void
-} & (
-	| {
-		fieldNode: FieldNode<FieldExtensions>
-		objectNode?: never
-	  }
-	| {
-		fieldNode?: never
-		objectNode: ObjectNode<FieldArgs, FieldExtensions>
-	  }
-)
+> =
+	& {
+		mapper: Mapper
+		path: Path
+		entity: Model.Entity
+		relationPath: Model.AnyRelationContext[]
+		addPredicate: (predicate: Acl.Predicate) => (row: SelectRow) => boolean
+		addColumn: (args: {
+			predicate?: Acl.Predicate
+			query?: (qb: SelectBuilder<SelectBuilder.Result>) => SelectBuilder<SelectBuilder.Result>
+			path?: Path
+			valueGetter?: ColumnValueGetter
+		}) => void
+		addData: (args: {
+			field: string
+			dataProvider: DataCallback
+			predicate?: Acl.Predicate
+			defaultValue?: SelectNestedDefaultValue
+		}) => void
+	}
+	& (
+		| {
+			fieldNode: FieldNode<FieldExtensions>
+			objectNode?: never
+		}
+		| {
+			fieldNode?: never
+			objectNode: ObjectNode<FieldArgs, FieldExtensions>
+		}
+	)

package/src/mapper/select/SelectHydrator.ts

@@ -90,7 +90,7 @@ export class SelectHydrator {
 		for (let { path, getParentValue, data, defaultValue } of resolvedData) {
 			const pathTmp = [...path.path]
 			const last = pathTmp.pop() as string
-			const currentObject = pathTmp.reduce<any>((obj, part) => (obj && obj[part]) || undefined, result)
+			const currentObject = pathTmp.reduce<any>((obj, part) => (obj?.[part]) || undefined, result)
 			const parentValue = getParentValue(row)
 			if (currentObject) {
 				currentObject[last] = (parentValue ? data[parentValue] : undefined) || defaultValue

package/src/mapper/select/WhereBuilder.ts

@@ -4,13 +4,7 @@ import { Input, Model } from '@contember/schema'
 import { Path, PathFactory } from './Path'
 import { JoinBuilder } from './JoinBuilder'
 import { ConditionBuilder } from './ConditionBuilder'
-import {
-	ConditionBuilder as SqlConditionBuilder,
-	Literal,
-	Operator,
-	QueryBuilder,
-	SelectBuilder, wrapIdentifier,
-} from '@contember/database'
+import { ConditionBuilder as SqlConditionBuilder, Literal, Operator, QueryBuilder, SelectBuilder, wrapIdentifier } from '@contember/database'
 import { WhereOptimizationHints, WhereOptimizer } from './optimizer/WhereOptimizer'
 
 export class WhereBuilder {
@@ -40,7 +34,6 @@ export class WhereBuilder {
 		})
 	}
 
-
 	public buildAdvanced<R extends SelectBuilder.Result>(
 		entity: Model.Entity,
 		path: Path,
@@ -61,15 +54,22 @@ export class WhereBuilder {
 	private buildInternal<R extends SelectBuilder.Result>({
 		callback,
 		...args
-	}: { entity: Model.Entity; path: Path; where: Input.OptionalWhere; callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<R>; allowManyJoin: boolean },
-	): SelectBuilder<R> {
+	}: {
+		entity: Model.Entity
+		path: Path
+		where: Input.OptionalWhere
+		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<R>
+		allowManyJoin: boolean
+	}): SelectBuilder<R> {
 		const joinList: WhereJoinDefinition[] = []
 
-		const qbWithWhere = callback(clause => this.buildRecursive({
-			conditionBuilder: clause,
-			joinList: joinList,
-			...args,
-		}))
+		const qbWithWhere = callback(clause =>
+			this.buildRecursive({
+				conditionBuilder: clause,
+				joinList: joinList,
+				...args,
+			})
+		)
 		return joinList.reduce<SelectBuilder<R>>(
 			(qb, { path, entity, relationName }) => this.joinBuilder.join<R>(qb, path, entity, relationName),
 			qbWithWhere,
@@ -83,8 +83,14 @@ export class WhereBuilder {
 		where,
 		joinList,
 		allowManyJoin,
-	}: { conditionBuilder: SqlConditionBuilder; entity: Model.Entity; path: Path; where: Input.OptionalWhere; joinList: WhereJoinDefinition[]; allowManyJoin: boolean },
-	): SqlConditionBuilder {
+	}: {
+		conditionBuilder: SqlConditionBuilder
+		entity: Model.Entity
+		path: Path
+		where: Input.OptionalWhere
+		joinList: WhereJoinDefinition[]
+		allowManyJoin: boolean
+	}): SqlConditionBuilder {
 		const tableName = path.alias
 
 		if (where.and !== undefined && where.and !== null && where.and.length > 0) {
@@ -101,7 +107,7 @@ export class WhereBuilder {
 							allowManyJoin,
 						}),
 					clause,
-				),
+				)
 			)
 		}
 		if (where.or !== undefined && where.or !== null && where.or.length > 0) {
@@ -111,16 +117,18 @@ export class WhereBuilder {
 					(clause2, where) =>
 						!where
 							? clause2
-							: clause2.and(clause3 => this.buildRecursive({
-								conditionBuilder: clause3,
-								entity,
-								path,
-								where,
-								joinList,
-								allowManyJoin,
-							})),
+							: clause2.and(clause3 =>
+								this.buildRecursive({
+									conditionBuilder: clause3,
+									entity,
+									path,
+									where,
+									joinList,
+									allowManyJoin,
+								})
+							),
 					clause,
-				),
+				)
 			)
 		}
 		if (where.not !== undefined && where.not !== null) {
@@ -133,7 +141,7 @@ export class WhereBuilder {
 					where: expr,
 					joinList,
 					allowManyJoin,
-				}),
+				})
 			)
 		}
 
@@ -160,7 +168,7 @@ export class WhereBuilder {
 							conditionBuilder,
 							tableName,
 							relation.joiningColumn.columnName,
-							(targetEntity.fields[targetEntity.primary] as Model.AnyColumn),
+							targetEntity.fields[targetEntity.primary] as Model.AnyColumn,
 							primaryCondition,
 						)
 					}
@@ -178,8 +186,6 @@ export class WhereBuilder {
 				})
 			}
 
-
-
 			conditionBuilder = acceptFieldVisitor<SqlConditionBuilder>(this.schema, entity, fieldName, {
 				visitColumn: ({ entity, column }) => {
 					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, column, fieldWhere as Input.Condition<Input.ColumnValue>)
@@ -232,8 +238,10 @@ export class WhereBuilder {
 						? SelectBuilder.create()
 							.select(it => it.raw('1'))
 							.from(new Literal(`(select ${wrapIdentifier(tableName)}.${wrapIdentifier(entity.primaryColumn)})`), targetPath.for('tmp_').alias)
-							.leftJoin(context.targetEntity.tableName, targetPath.alias, it =>
-								it.columnsEq([targetPath.for('tmp_').alias, entity.primaryColumn], [targetPath.alias, context.targetRelation.joiningColumn.columnName]),
+							.leftJoin(
+								context.targetEntity.tableName,
+								targetPath.alias,
+								it => it.columnsEq([targetPath.for('tmp_').alias, entity.primaryColumn], [targetPath.alias, context.targetRelation.joiningColumn.columnName]),
 							)
 						: SelectBuilder.create()
 							.select(it => it.raw('1'))
@@ -255,7 +263,6 @@ export class WhereBuilder {
 		return conditionBuilder
 	}
 
-
 	private createManyHasManySubquery(
 		outerColumn: QueryBuilder.ColumnIdentifier,
 		relationWhere: Input.OptionalWhere,
@@ -274,16 +281,15 @@ export class WhereBuilder {
 
 		const primaryCondition = this.transformWhereToPrimaryCondition(relationWhere, targetEntity.primary)
 		if (primaryCondition !== null) {
+			const columnType = targetEntity.fields[targetEntity.primary] as Model.AnyColumn
 
-			const columnType = (targetEntity.fields[targetEntity.primary] as Model.AnyColumn)
-
-			return qb.where(condition =>
-				this.conditionBuilder.build(condition, junctionPath.alias, toColumn, columnType, primaryCondition),
-			)
+			return qb.where(condition => this.conditionBuilder.build(condition, junctionPath.alias, toColumn, columnType, primaryCondition))
 		}
 
-		const qbJoined = qb.join(targetEntity.tableName, path.alias, clause =>
-			clause.compareColumns([junctionPath.alias, toColumn], Operator.eq, [path.alias, targetEntity.primary]),
+		const qbJoined = qb.join(
+			targetEntity.tableName,
+			path.alias,
+			clause => clause.compareColumns([junctionPath.alias, toColumn], Operator.eq, [path.alias, targetEntity.primary]),
 		)
 		return this.buildInternal({
 			entity: targetEntity,
@@ -359,10 +365,10 @@ export class WhereBuilder {
 		if (cond.isNull !== undefined) {
 			return true
 		}
-		if (cond.and && cond.and.some(it => this.conditionHasIsNull(it))) {
+		if (cond.and?.some(it => this.conditionHasIsNull(it))) {
 			return true
 		}
-		if (cond.or && cond.or.some(it => this.conditionHasIsNull(it))) {
+		if (cond.or?.some(it => this.conditionHasIsNull(it))) {
 			return true
 		}
 		if (cond.not && this.conditionHasIsNull(cond.not)) {

package/src/mapper/select/handlers/FieldsVisitor.ts

@@ -38,7 +38,7 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 			selectFrom += '::text[]'
 		}
 
-		let columnValueGetter: ColumnValueGetter | undefined = undefined
+		let columnValueGetter: ColumnValueGetter | undefined
 		if (entity.view && column.name === entity.primary && column.type === Model.ColumnType.Uuid) {
 			if (entity.view.idSource) {
 				const aliases: string[] = []
@@ -58,7 +58,6 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				columnValueGetter = row => {
 					return row[columnAlias] ?? (this.providers.uuid({ version: this.settings.uuidVersion }))
 				}
-
 			}
 		}
 

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

@@ -13,25 +13,18 @@ export class ConditionOptimizer {
 			(Object.entries(condition) as ObjectEntry<typeof condition>[]).map(([key, value]) => {
 				if (value === undefined || value === null) {
 					return undefined
-
 				} else if (key === 'always') {
 					return true
-
 				} else if (key === 'and') {
 					return optimizeAnd(value.map(it => this.optimize(it)))
-
 				} else if (key === 'or') {
 					return optimizeOr(value.map(it => this.optimize(it)))
-
 				} else if (key === 'in' && value.length === 0) {
 					return false
-
 				} else if (key === 'notIn' && value.length === 0) {
 					return true
-
 				} else if (key === 'not') {
 					return optimizeNot(this.optimize(value))
-
 				} else {
 					return { [key]: value }
 				}

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

@@ -4,12 +4,11 @@ import { acceptFieldVisitor } from '@contember/schema-utils'
 import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
 import { replaceWhere } from './WhereReplacer'
 
-type ExtendedRelationContext =
-	& {
-		context: Model.AnyRelationContext
-		canEliminate: boolean
-		isLast: boolean
-	}
+type ExtendedRelationContext = {
+	context: Model.AnyRelationContext
+	canEliminate: boolean
+	isLast: boolean
+}
 
 export interface WhereOptimizationHints {
 	relationPath?: Model.AnyRelationContext[]
@@ -18,16 +17,29 @@ export interface WhereOptimizationHints {
 
 type OptimizedOperand = Input.OptionalWhere | undefined | boolean
 
+export type WhereOptimizerOptions = {
+	disable?: boolean
+	maxCrossOptimizationInput?: number
+}
+
 export class WhereOptimizer {
 	private static eliminableRelations = new Set<Model.AnyRelationContext['type']>(['oneHasMany', 'oneHasOneInverse', 'oneHasOneOwning'])
 
 	constructor(
 		private readonly model: Model.Schema,
 		private readonly conditionOptimizer: ConditionOptimizer,
+		private readonly options?: WhereOptimizerOptions,
 	) {
 	}
 
-	public optimize(where: Input.OptionalWhere, entity: Model.Entity, { relationPath = [], evaluatedPredicates = [] }: WhereOptimizationHints = {}): Input.OptionalWhere {
+	public optimize(
+		where: Input.OptionalWhere,
+		entity: Model.Entity,
+		{ relationPath = [], evaluatedPredicates = [] }: WhereOptimizationHints = {},
+	): Input.OptionalWhere {
+		if (this.options?.disable) {
+			return where
+		}
 		let processedRelationPath: ExtendedRelationContext[] = []
 		for (const i in relationPath) {
 			const el = relationPath[i]
@@ -63,7 +75,7 @@ export class WhereOptimizer {
 
 		for (const key in where) {
 			const value = where[key]
-			let operand: OptimizedOperand = undefined
+			let operand: OptimizedOperand
 			if (value === undefined || value === null) {
 				continue
 			} else if (key === 'and') {
@@ -89,17 +101,14 @@ export class WhereOptimizer {
 				if (operand !== true) {
 					operand = this.optimizeOr(innerOperands, entity, relationPath)
 				}
-
 			} else if (key === 'not') {
 				operand = optimizeNot(this.optimizeWhere(value as Input.OptionalWhere, entity, relationPath))
-
 			} else {
 				operand = this.resolveFieldValue(entity, key, value, relationPath)
 			}
 
 			if (operand === false) {
 				return false
-
 			} else if (operand !== undefined) {
 				operands.push(operand)
 			}
@@ -107,7 +116,11 @@ export class WhereOptimizer {
 		return this.optimizeAnd(operands, entity, relationPath)
 	}
 
-	private optimizeOr(operands: readonly OptimizedOperand[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
+	private optimizeOr(
+		operands: readonly OptimizedOperand[],
+		entity: Model.Entity,
+		relationPath: ExtendedRelationContext[],
+	): Input.OptionalWhere | boolean {
 		const optimized = optimizeOr(operands)
 		if (typeof optimized === 'boolean' || !Array.isArray(optimized.or)) {
 			return optimized
@@ -119,7 +132,11 @@ export class WhereOptimizer {
 		return optimizeOr(result)
 	}
 
-	private optimizeAnd(operands: readonly OptimizedOperand[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
+	private optimizeAnd(
+		operands: readonly OptimizedOperand[],
+		entity: Model.Entity,
+		relationPath: ExtendedRelationContext[],
+	): Input.OptionalWhere | boolean {
 		const optimized = optimizeAnd(operands)
 		if (typeof optimized === 'boolean' || !Array.isArray(optimized.and)) {
 			return optimized
@@ -131,10 +148,15 @@ export class WhereOptimizer {
 		return optimizeAnd(result)
 	}
 
-	private crossOptimize(operands: Input.OptionalWhere[], entity: Model.Entity, replacement: Input.Condition, relationPath: ExtendedRelationContext[]): (Input.OptionalWhere | boolean)[] {
+	private crossOptimize(
+		operands: Input.OptionalWhere[],
+		entity: Model.Entity,
+		replacement: Input.Condition,
+		relationPath: ExtendedRelationContext[],
+	): (Input.OptionalWhere | boolean)[] {
 		let result: (Input.OptionalWhere | boolean)[] = operands
 		let copied = false
-		const count = result.length
+		const count = Math.min(result.length, this.options?.maxCrossOptimizationInput ?? 50)
 		for (let i = 0; i < count; i++) {
 			for (let j = 0; j < count; j++) {
 				const a = result[j]

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

@@ -1,7 +1,12 @@
 import { Input, Writable } from '@contember/schema'
 import deepEqual from 'fast-deep-equal'
 
-export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalWhere, replace: Input.OptionalWhere, opts: { replaceSubOperands?: boolean } = {}): Input.OptionalWhere => {
+export const replaceWhere = (
+	subject: Input.OptionalWhere,
+	find: Input.OptionalWhere,
+	replace: Input.OptionalWhere,
+	opts: { replaceSubOperands?: boolean } = {},
+): Input.OptionalWhere => {
 	if (deepEqual(subject, find)) {
 		return replace
 	}
@@ -42,13 +47,11 @@ export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalW
 					write(key, items)
 				}
 			}
-
 		}
 	}
 	return result
 }
 
-
 const containsAllOperands = (subjectOperands: Input.OptionalWhere[], findOperands: Input.OptionalWhere[]): boolean => {
 	for (const op1 of findOperands) {
 		let found = false

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

@@ -6,7 +6,7 @@ export const optimizeOr = <P extends Record<string, unknown>>(operands: readonly
 			return true
 		} else if (operand === false) {
 			hasNever = true
-		} else if (operand !== undefined)  {
+		} else if (operand !== undefined) {
 			normalized.push(...Array.isArray(operand.or) ? operand.or : [operand])
 		}
 	}