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

package/src/acl/PredicatesInjector.ts

@@ -1,6 +1,6 @@
 import { Acl, Input, Model, Writable } from '@contember/schema'
 import { acceptFieldVisitor } from '@contember/schema-utils'
-import { PredicateFactory } from './PredicateFactory'
+import { PredicateFactory } from './PredicateFactory.js'
 
 export class PredicatesInjector {
 	constructor(private readonly schema: Model.Schema, private readonly predicateFactory: PredicateFactory) {}
@@ -11,8 +11,9 @@ export class PredicatesInjector {
 		relationContext?: Model.AnyRelationContext,
 		ancestorPath?: readonly Model.AnyRelationContext[],
 	): Input.OptionalWhere {
-		const restrictedWhere = this.injectToWhere(where, entity, true, relationContext, false, ancestorPath ?? [])
-		return this.createWhere(entity, undefined, restrictedWhere, relationContext, false, ancestorPath ?? [])
+		const isQueryRoot = !relationContext && (!ancestorPath || ancestorPath.length === 0)
+		const restrictedWhere = this.injectToWhere(where, entity, true, relationContext, false, ancestorPath ?? [], isQueryRoot)
+		return this.createWhere(entity, undefined, restrictedWhere, relationContext, false, ancestorPath ?? [], isQueryRoot)
 	}
 
 	/**
@@ -40,6 +41,7 @@ export class PredicatesInjector {
 		relationContext?: Model.AnyRelationContext,
 		isBackReferenceContext?: boolean,
 		ancestorPath?: readonly Model.AnyRelationContext[],
+		isQueryRoot?: boolean,
 	): Input.OptionalWhere {
 		// Simplify predicates when:
 		// 1. We're in a back-reference context (inside a filter that traverses back)
@@ -55,13 +57,14 @@ export class PredicatesInjector {
 		if (shouldSimplify) {
 			predicatesWhere = { [entity.primary]: { always: true } }
 		} else {
-			const rawPredicate = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, relationContext)
+			const rawPredicate = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, relationContext, isQueryRoot)
 			// Process the predicate to inject nested entity predicates
 			predicatesWhere = this.injectPredicatesToPredicate(
 				rawPredicate,
 				entity,
 				isBackReferenceContext ?? false,
 				ancestorPath ?? [],
+				isQueryRoot,
 			)
 		}
 
@@ -85,21 +88,22 @@ export class PredicatesInjector {
 		entity: Model.Entity,
 		isBackReferenceContext: boolean,
 		ancestorPath: readonly Model.AnyRelationContext[],
+		isQueryRoot?: boolean,
 	): Input.OptionalWhere {
 		const resultWhere: Writable<Input.OptionalWhere> = {}
 
 		if (where.and) {
 			resultWhere.and = where.and
 				.filter((it): it is Input.Where => !!it)
-				.map(it => this.injectPredicatesToPredicate(it, entity, isBackReferenceContext, ancestorPath))
+				.map(it => this.injectPredicatesToPredicate(it, entity, isBackReferenceContext, ancestorPath, isQueryRoot))
 		}
 		if (where.or) {
 			resultWhere.or = where.or
 				.filter((it): it is Input.Where => !!it)
-				.map(it => this.injectPredicatesToPredicate(it, entity, isBackReferenceContext, ancestorPath))
+				.map(it => this.injectPredicatesToPredicate(it, entity, isBackReferenceContext, ancestorPath, isQueryRoot))
 		}
 		if (where.not) {
-			resultWhere.not = this.injectPredicatesToPredicate(where.not, entity, isBackReferenceContext, ancestorPath)
+			resultWhere.not = this.injectPredicatesToPredicate(where.not, entity, isBackReferenceContext, ancestorPath, isQueryRoot)
 		}
 
 		const fields = Object.keys(where).filter(it => !['and', 'or', 'not'].includes(it))
@@ -128,6 +132,7 @@ export class PredicatesInjector {
 						context.targetEntity,
 						nestedIsBackReferenceContext,
 						nestedAncestorPath,
+						isQueryRoot,
 					)
 
 					// Check if we should simplify the target entity's predicate
@@ -137,7 +142,7 @@ export class PredicatesInjector {
 					// Get target entity's predicate (simplified if back-reference)
 					const targetPredicate = shouldSimplifyNested
 						? { [context.targetEntity.primary]: { always: true } }
-						: this.predicateFactory.create(context.targetEntity, Acl.Operation.read, undefined, context)
+						: this.predicateFactory.create(context.targetEntity, Acl.Operation.read, undefined, context, isQueryRoot)
 
 					// Optimization: avoid duplicate { id: always } when both are simplified
 					const primaryKey = context.targetEntity.primary
@@ -175,20 +180,21 @@ export class PredicatesInjector {
 		relationContext: Model.AnyRelationContext | undefined,
 		isBackReferenceContext: boolean,
 		ancestorPath: readonly Model.AnyRelationContext[],
+		isQueryRoot?: boolean,
 	): Input.OptionalWhere {
 		const resultWhere: Writable<Input.OptionalWhere> = {}
 		if (where.and) {
 			resultWhere.and = where.and.filter((it): it is Input.Where => !!it).map(it =>
-				this.injectToWhere(it, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath)
+				this.injectToWhere(it, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath, isQueryRoot)
 			)
 		}
 		if (where.or) {
 			resultWhere.or = where.or.filter((it): it is Input.Where => !!it).map(it =>
-				this.injectToWhere(it, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath)
+				this.injectToWhere(it, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath, isQueryRoot)
 			)
 		}
 		if (where.not) {
-			resultWhere.not = this.injectToWhere(where.not, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath)
+			resultWhere.not = this.injectToWhere(where.not, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath, isQueryRoot)
 		}
 
 		const fields = Object.keys(where).filter(it => !['and', 'or', 'not'].includes(it))
@@ -210,14 +216,14 @@ export class PredicatesInjector {
 					const nestedIsBackReferenceContext = isBackReference || isBackReferenceContext
 					// Build extended ancestor path for nested traversal
 					const nestedAncestorPath: Model.AnyRelationContext[] = [...ancestorPath, context]
-					return this.injectToWhere(relationWhere, context.targetEntity, false, context, nestedIsBackReferenceContext, nestedAncestorPath)
+					return this.injectToWhere(relationWhere, context.targetEntity, false, context, nestedIsBackReferenceContext, nestedAncestorPath, isQueryRoot)
 				},
 			})
 		}
 		const fieldsForPredicate = !isRoot
 			? fields
-			: fields.filter(it => this.predicateFactory.shouldApplyCellLevelPredicate(entity, Acl.Operation.read, it))
+			: fields.filter(it => this.predicateFactory.shouldApplyCellLevelPredicate(entity, Acl.Operation.read, it, isQueryRoot))
 
-		return this.createWhere(entity, fieldsForPredicate, resultWhere, relationContext, isBackReferenceContext, ancestorPath)
+		return this.createWhere(entity, fieldsForPredicate, resultWhere, relationContext, isBackReferenceContext, ancestorPath, isQueryRoot)
 	}
 }

package/src/acl/index.ts

@@ -1,6 +1,6 @@
-export * from './Authorizator'
-export * from './PermissionFactory'
-export * from './PredicateFactory'
-export * from './PredicatesInjector'
-export * from './VariableInjector'
-export * from './VariableUtils'
+export * from './Authorizator.js'
+export * from './PermissionFactory.js'
+export * from './PredicateFactory.js'
+export * from './PredicatesInjector.js'
+export * from './VariableInjector.js'
+export * from './VariableUtils.js'

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducer.ts

@@ -1,7 +1,7 @@
-import { EntityFieldsProvider, FieldMap } from '../EntityFieldsProvider'
+import { EntityFieldsProvider, FieldMap } from '../EntityFieldsProvider.js'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
-import { HasManyToHasOneRelationReducerFieldVisitor } from './HasManyToHasOneRelationReducerVisitor'
+import { HasManyToHasOneRelationReducerFieldVisitor } from './HasManyToHasOneRelationReducerVisitor.js'
 
 export class HasManyToHasOneReducer implements EntityFieldsProvider<HasManyToHasOneReducerExtension> {
 	static extensionName: string = 'HasManyToHasOneReducer'

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducerExecutionHandler.ts

@@ -1,10 +1,10 @@
 import { Input, Model } from '@contember/schema'
-import { isIt } from '../../utils'
+import { isIt } from '../../utils/index.js'
 import { acceptFieldVisitor } from '@contember/schema-utils'
-import { SelectExecutionHandler, SelectExecutionHandlerContext } from '../../mapper'
-import { ImplementationException } from '../../exception'
-import { UniqueWhereExpander } from '../../inputProcessing'
-import { HasManyToHasOneReducerExtension } from './HasManyToHasOneReducer'
+import { SelectExecutionHandler, SelectExecutionHandlerContext } from '../../mapper/index.js'
+import { ImplementationException } from '../../exception.js'
+import { UniqueWhereExpander } from '../../inputProcessing/index.js'
+import { HasManyToHasOneReducerExtension } from './HasManyToHasOneReducer.js'
 
 export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHandler<Input.UniqueQueryInput, HasManyToHasOneReducerExtension> {
 	constructor(private readonly schema: Model.Schema, private readonly uniqueWhereExpander: UniqueWhereExpander) {}

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneRelationReducerVisitor.ts

@@ -1,10 +1,10 @@
 import { GraphQLInputObjectType, GraphQLNonNull } from 'graphql'
 import { Acl, Model } from '@contember/schema'
-import { aliasAwareResolver, EntityTypeProvider, FieldAccessVisitor, GqlTypeName, WhereTypeProvider } from '../../schema'
+import { aliasAwareResolver, EntityTypeProvider, FieldAccessVisitor, GqlTypeName, WhereTypeProvider } from '../../schema/index.js'
 import { acceptFieldVisitor } from '@contember/schema-utils'
-import { Authorizator } from '../../acl'
-import { getFieldsForUniqueWhere } from '../../utils'
-import { HasManyToHasOneReducer, HasManyToHasOneReducerExtension } from './HasManyToHasOneReducer'
+import { Authorizator } from '../../acl/index.js'
+import { getFieldsForUniqueWhere } from '../../utils/index.js'
+import { HasManyToHasOneReducer, HasManyToHasOneReducerExtension } from './HasManyToHasOneReducer.js'
 import { GraphQLFieldConfig } from 'graphql'
 
 type Result = [

package/src/extensions/hasManyToHasOneReducer/index.ts

@@ -1,3 +1,3 @@
-export * from './HasManyToHasOneReducer'
-export * from './HasManyToHasOneReducerExecutionHandler'
-export * from './HasManyToHasOneRelationReducerVisitor'
+export * from './HasManyToHasOneReducer.js'
+export * from './HasManyToHasOneReducerExecutionHandler.js'
+export * from './HasManyToHasOneRelationReducerVisitor.js'

package/src/extensions/index.ts

@@ -1,2 +1,2 @@
-export * from './EntityFieldsProvider'
-export * from './hasManyToHasOneReducer'
+export * from './EntityFieldsProvider.js'
+export * from './hasManyToHasOneReducer/index.js'

package/src/extensions/paginatedHasMany/PaginatedHasManyCountVisitor.ts

@@ -1,6 +1,6 @@
 import { Input, Model } from '@contember/schema'
-import { GroupedCounts, Mapper, RelationFetcher } from '../../mapper'
-import { ObjectNode } from '../../inputProcessing'
+import { GroupedCounts, Mapper, RelationFetcher } from '../../mapper/index.js'
+import { ObjectNode } from '../../inputProcessing/index.js'
 
 export class PaginatedHasManyCountVisitor
 	implements Model.ColumnVisitor<Promise<GroupedCounts>>, Model.RelationByTypeVisitor<Promise<GroupedCounts>>

package/src/extensions/paginatedHasMany/PaginatedHasManyExecutionHandler.ts

@@ -1,10 +1,10 @@
 import { Input, Model } from '@contember/schema'
-import { RelationFetcher, SelectExecutionHandler, SelectExecutionHandlerContext } from '../../mapper'
-import { PaginatedHasManyFieldProviderExtension } from './PaginatedHasManyFieldProvider'
+import { RelationFetcher, SelectExecutionHandler, SelectExecutionHandlerContext } from '../../mapper/index.js'
+import { PaginatedHasManyFieldProviderExtension } from './PaginatedHasManyFieldProvider.js'
 import { acceptFieldVisitor } from '@contember/schema-utils'
-import { createPaginationHelper } from '../../utils'
-import { PaginatedHasManyCountVisitor } from './PaginatedHasManyCountVisitor'
-import { PaginatedHasManyNodesVisitor } from './PaginatedHasManyNodesVisitor'
+import { createPaginationHelper } from '../../utils/index.js'
+import { PaginatedHasManyCountVisitor } from './PaginatedHasManyCountVisitor.js'
+import { PaginatedHasManyNodesVisitor } from './PaginatedHasManyNodesVisitor.js'
 
 export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<Input.PaginationQueryInput, PaginatedHasManyFieldProviderExtension> {
 	constructor(

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProvider.ts

@@ -1,7 +1,7 @@
-import { EntityFieldsProvider, FieldMap } from '../EntityFieldsProvider'
+import { EntityFieldsProvider, FieldMap } from '../EntityFieldsProvider.js'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
-import { PaginatedHasManyFieldProviderVisitor } from './PaginatedHasManyFieldProviderVisitor'
+import { PaginatedHasManyFieldProviderVisitor } from './PaginatedHasManyFieldProviderVisitor.js'
 
 export class PaginatedHasManyFieldProvider implements EntityFieldsProvider<PaginatedHasManyFieldProviderExtension> {
 	static extensionName: string = 'PaginatedHasMany'

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor.ts

@@ -1,8 +1,8 @@
 import { Model } from '@contember/schema'
-import { PaginatedHasManyFieldProvider, PaginatedHasManyFieldProviderExtension } from './PaginatedHasManyFieldProvider'
-import { capitalizeFirstLetter } from '../../utils'
-import { PaginatedFieldConfigFactory } from '../../schema/PaginatedFieldConfigFactory'
-import { aliasAwareResolver } from '../../schema'
+import { PaginatedHasManyFieldProvider, PaginatedHasManyFieldProviderExtension } from './PaginatedHasManyFieldProvider.js'
+import { capitalizeFirstLetter } from '../../utils/index.js'
+import { PaginatedFieldConfigFactory } from '../../schema/PaginatedFieldConfigFactory.js'
+import { aliasAwareResolver } from '../../schema/index.js'
 import { GraphQLFieldConfig } from 'graphql'
 
 type Result = [

package/src/extensions/paginatedHasMany/PaginatedHasManyNodesVisitor.ts

@@ -1,6 +1,6 @@
 import { Input, Model } from '@contember/schema'
-import { Mapper, RelationFetcher, SelectGroupedObjects } from '../../mapper'
-import { ObjectNode } from '../../inputProcessing'
+import { Mapper, RelationFetcher, SelectGroupedObjects } from '../../mapper/index.js'
+import { ObjectNode } from '../../inputProcessing/index.js'
 
 export class PaginatedHasManyNodesVisitor
 	implements Model.ColumnVisitor<Promise<SelectGroupedObjects>>, Model.RelationByTypeVisitor<Promise<SelectGroupedObjects>>

package/src/index.ts

@@ -1,13 +1,13 @@
-export * from './acl'
-export * from './resolvers'
-export * from './introspection'
-export * from './schema'
-export * from './inputProcessing'
-export { EntityRulesResolver } from './input-validation'
-export * from './types'
-export * from './ExecutionContainer'
+export * from './acl/index.js'
+export * from './resolvers/index.js'
+export * from './introspection/index.js'
+export * from './schema/index.js'
+export * from './inputProcessing/index.js'
+export { EntityRulesResolver } from './input-validation/index.js'
+export * from './types.js'
+export * from './ExecutionContainer.js'
 export { graphql } from 'graphql'
-export { UserError } from './exception'
+export { UserError } from './exception.js'
 export {
 	AfterCommitEvent,
 	AfterInsertEvent,
@@ -31,5 +31,5 @@ export {
 	Path,
 	PathFactory,
 	type WhereBuilder,
-} from './mapper'
-export * from './utils/uniqueWhereFields'
+} from './mapper/index.js'
+export * from './utils/uniqueWhereFields.js'

package/src/input-validation/EntityRulesResolver.ts

@@ -1,9 +1,9 @@
-import { filterObject, mapObject } from '../utils'
+import { filterObject, mapObject } from '../utils/index.js'
 import { Model, Validation } from '@contember/schema'
 import { acceptEveryFieldVisitor, acceptFieldVisitor } from '@contember/schema-utils'
 import { InputValidation } from '@contember/schema-definition'
-import { DependencyCollector } from './dependencies'
-import { NotSupportedError } from './exceptions'
+import { DependencyCollector } from './dependencies/index.js'
+import { NotSupportedError } from './exceptions.js'
 
 export class EntityRulesResolver {
 	constructor(private readonly validationSchema: Validation.Schema, private readonly model: Model.Schema) {}

package/src/input-validation/InputValidator.ts

@@ -1,4 +1,4 @@
-import { ValidationPath } from './ValidationPath'
+import { ValidationPath } from './ValidationPath.js'
 import { Validation } from '@contember/schema'
 
 export interface FieldValidationResult {

package/src/input-validation/JsonSchemaValidator.ts

@@ -0,0 +1,257 @@
+import { JSONValue } from '@contember/schema'
+
+export interface JsonSchemaValidationError {
+	/** JSON pointer-ish path within the validated value, e.g. `/foo/0/bar`. */
+	path: string
+	message: string
+}
+
+type JsonSchema = { readonly [key: string]: JSONValue } | boolean
+
+/**
+ * A pragmatic, dependency-free validator for a *subset* of JSON Schema. It is intentionally not a
+ * full draft 2020-12 implementation — it only understands the keywords listed below.
+ *
+ * Supported keywords:
+ * - `type` (string or array of strings: object, array, string, number, integer, boolean, null)
+ * - `enum`, `const`
+ * - object: `properties`, `required`, `additionalProperties`, `minProperties`, `maxProperties`
+ * - array: `items` (applied to ALL elements, draft-07 style), `minItems`, `maxItems`, `uniqueItems`
+ * - string: `minLength`, `maxLength`, `pattern`
+ * - number: `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf`
+ * - combinators: `allOf`, `anyOf`, `oneOf`, `not`
+ *
+ * Any other keyword is SILENTLY IGNORED (treated as valid) — including `$ref`, `$defs`, `format`,
+ * `patternProperties`, `propertyNames`, `dependentRequired`, `dependentSchemas`, `if`/`then`/`else`,
+ * `contains`, and the 2020-12 tuple keyword `prefixItems`. Such keywords look validated but are not.
+ */
+export const validateJsonSchema = (schema: JSONValue, value: JSONValue | undefined): JsonSchemaValidationError[] => {
+	const errors: JsonSchemaValidationError[] = []
+	validateNode(schema as JsonSchema, value === undefined ? null : value, '', errors)
+	return errors
+}
+
+const jsonType = (value: JSONValue): 'object' | 'array' | 'string' | 'number' | 'boolean' | 'null' => {
+	if (value === null) {
+		return 'null'
+	}
+	if (Array.isArray(value)) {
+		return 'array'
+	}
+	return typeof value as 'object' | 'string' | 'number' | 'boolean'
+}
+
+const matchesType = (expected: string, value: JSONValue): boolean => {
+	const actual = jsonType(value)
+	if (expected === 'integer') {
+		return actual === 'number' && Number.isInteger(value as number)
+	}
+	if (expected === 'number') {
+		return actual === 'number'
+	}
+	return actual === expected
+}
+
+const deepEqual = (a: JSONValue, b: JSONValue): boolean => {
+	if (a === b) {
+		return true
+	}
+	const ta = jsonType(a)
+	const tb = jsonType(b)
+	if (ta !== tb) {
+		return false
+	}
+	if (ta === 'array') {
+		const aa = a as readonly JSONValue[]
+		const ba = b as readonly JSONValue[]
+		return aa.length === ba.length && aa.every((it, i) => deepEqual(it, ba[i]))
+	}
+	if (ta === 'object') {
+		const ao = a as { readonly [key: string]: JSONValue }
+		const bo = b as { readonly [key: string]: JSONValue }
+		const aKeys = Object.keys(ao)
+		const bKeys = Object.keys(bo)
+		return aKeys.length === bKeys.length && aKeys.every(key => key in bo && deepEqual(ao[key], bo[key]))
+	}
+	return false
+}
+
+const validateNode = (schema: JsonSchema, value: JSONValue, path: string, errors: JsonSchemaValidationError[]): void => {
+	if (schema === true || schema === undefined) {
+		return
+	}
+	if (schema === false) {
+		errors.push({ path, message: 'Value is not allowed here' })
+		return
+	}
+
+	if ('type' in schema) {
+		const types = Array.isArray(schema.type) ? (schema.type as string[]) : [schema.type as string]
+		if (!types.some(it => matchesType(it, value))) {
+			errors.push({ path, message: `Expected type ${types.join(' or ')}, got ${jsonType(value)}` })
+			return
+		}
+	}
+
+	if ('const' in schema && schema.const !== undefined) {
+		if (!deepEqual(schema.const, value)) {
+			errors.push({ path, message: 'Value does not match the expected constant' })
+		}
+	}
+
+	if (Array.isArray(schema.enum)) {
+		if (!schema.enum.some(it => deepEqual(it, value))) {
+			errors.push({ path, message: 'Value is not one of the allowed values' })
+		}
+	}
+
+	const type = jsonType(value)
+
+	if (type === 'string') {
+		validateString(schema, value as string, path, errors)
+	}
+	if (type === 'number') {
+		validateNumber(schema, value as number, path, errors)
+	}
+	if (type === 'array') {
+		validateArray(schema, value as readonly JSONValue[], path, errors)
+	}
+	if (type === 'object') {
+		validateObject(schema, value as { readonly [key: string]: JSONValue }, path, errors)
+	}
+
+	validateCombinators(schema, value, path, errors)
+}
+
+const validateString = (schema: Exclude<JsonSchema, boolean>, value: string, path: string, errors: JsonSchemaValidationError[]): void => {
+	if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
+		errors.push({ path, message: `String is shorter than ${schema.minLength} characters` })
+	}
+	if (typeof schema.maxLength === 'number' && value.length > schema.maxLength) {
+		errors.push({ path, message: `String is longer than ${schema.maxLength} characters` })
+	}
+	if (typeof schema.pattern === 'string') {
+		try {
+			if (!new RegExp(schema.pattern).test(value)) {
+				errors.push({ path, message: `String does not match pattern ${schema.pattern}` })
+			}
+		} catch {
+			// invalid pattern in schema – ignore
+		}
+	}
+}
+
+const validateNumber = (schema: Exclude<JsonSchema, boolean>, value: number, path: string, errors: JsonSchemaValidationError[]): void => {
+	if (typeof schema.minimum === 'number' && value < schema.minimum) {
+		errors.push({ path, message: `Value is less than minimum ${schema.minimum}` })
+	}
+	if (typeof schema.maximum === 'number' && value > schema.maximum) {
+		errors.push({ path, message: `Value is greater than maximum ${schema.maximum}` })
+	}
+	if (typeof schema.exclusiveMinimum === 'number' && value <= schema.exclusiveMinimum) {
+		errors.push({ path, message: `Value is not greater than ${schema.exclusiveMinimum}` })
+	}
+	if (typeof schema.exclusiveMaximum === 'number' && value >= schema.exclusiveMaximum) {
+		errors.push({ path, message: `Value is not less than ${schema.exclusiveMaximum}` })
+	}
+	if (typeof schema.multipleOf === 'number' && schema.multipleOf > 0 && !Number.isInteger(value / schema.multipleOf)) {
+		errors.push({ path, message: `Value is not a multiple of ${schema.multipleOf}` })
+	}
+}
+
+const validateArray = (
+	schema: Exclude<JsonSchema, boolean>,
+	value: readonly JSONValue[],
+	path: string,
+	errors: JsonSchemaValidationError[],
+): void => {
+	if (typeof schema.minItems === 'number' && value.length < schema.minItems) {
+		errors.push({ path, message: `Array has fewer than ${schema.minItems} items` })
+	}
+	if (typeof schema.maxItems === 'number' && value.length > schema.maxItems) {
+		errors.push({ path, message: `Array has more than ${schema.maxItems} items` })
+	}
+	if (schema.uniqueItems === true) {
+		for (let i = 0; i < value.length; i++) {
+			for (let j = i + 1; j < value.length; j++) {
+				if (deepEqual(value[i], value[j])) {
+					errors.push({ path, message: 'Array items are not unique' })
+					i = value.length
+					break
+				}
+			}
+		}
+	}
+	if (schema.items !== undefined) {
+		value.forEach((item, index) => {
+			validateNode(schema.items as JsonSchema, item, `${path}/${index}`, errors)
+		})
+	}
+}
+
+const validateObject = (
+	schema: Exclude<JsonSchema, boolean>,
+	value: { readonly [key: string]: JSONValue },
+	path: string,
+	errors: JsonSchemaValidationError[],
+): void => {
+	const keys = Object.keys(value)
+	if (Array.isArray(schema.required)) {
+		for (const required of schema.required as string[]) {
+			if (!(required in value)) {
+				errors.push({ path: `${path}/${required}`, message: 'Required property is missing' })
+			}
+		}
+	}
+	if (typeof schema.minProperties === 'number' && keys.length < schema.minProperties) {
+		errors.push({ path, message: `Object has fewer than ${schema.minProperties} properties` })
+	}
+	if (typeof schema.maxProperties === 'number' && keys.length > schema.maxProperties) {
+		errors.push({ path, message: `Object has more than ${schema.maxProperties} properties` })
+	}
+	const properties = (schema.properties ?? {}) as { readonly [key: string]: JSONValue }
+	for (const key of keys) {
+		if (key in properties) {
+			validateNode(properties[key] as JsonSchema, value[key], `${path}/${key}`, errors)
+		} else if (schema.additionalProperties === false) {
+			errors.push({ path: `${path}/${key}`, message: 'Additional property is not allowed' })
+		} else if (schema.additionalProperties !== undefined && schema.additionalProperties !== true) {
+			validateNode(schema.additionalProperties as JsonSchema, value[key], `${path}/${key}`, errors)
+		}
+	}
+}
+
+const validateCombinators = (schema: Exclude<JsonSchema, boolean>, value: JSONValue, path: string, errors: JsonSchemaValidationError[]): void => {
+	if (Array.isArray(schema.allOf)) {
+		for (const sub of schema.allOf) {
+			validateNode(sub as JsonSchema, value, path, errors)
+		}
+	}
+	if (Array.isArray(schema.anyOf)) {
+		const matches = (schema.anyOf as JsonSchema[]).some(sub => {
+			const subErrors: JsonSchemaValidationError[] = []
+			validateNode(sub, value, path, subErrors)
+			return subErrors.length === 0
+		})
+		if (!matches) {
+			errors.push({ path, message: 'Value does not match any of the allowed schemas' })
+		}
+	}
+	if (Array.isArray(schema.oneOf)) {
+		const matchCount = (schema.oneOf as JsonSchema[]).filter(sub => {
+			const subErrors: JsonSchemaValidationError[] = []
+			validateNode(sub, value, path, subErrors)
+			return subErrors.length === 0
+		}).length
+		if (matchCount !== 1) {
+			errors.push({ path, message: 'Value must match exactly one of the allowed schemas' })
+		}
+	}
+	if (schema.not !== undefined) {
+		const subErrors: JsonSchemaValidationError[] = []
+		validateNode(schema.not as JsonSchema, value, path, subErrors)
+		if (subErrors.length === 0) {
+			errors.push({ path, message: 'Value matches a forbidden schema' })
+		}
+	}
+}

package/src/input-validation/QueryAstFactory.ts

@@ -1,7 +1,7 @@
 import { acceptFieldVisitor, getEntity } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
-import { Dependencies } from './dependencies'
-import { FieldNode, ObjectNode } from '../inputProcessing'
+import { Dependencies } from './dependencies/index.js'
+import { FieldNode, ObjectNode } from '../inputProcessing/index.js'
 
 export class QueryAstFactory {
 	constructor(private readonly model: Model.Schema) {}

package/src/input-validation/ValidationContext.ts

@@ -1,5 +1,5 @@
 import { Validation, Value } from '@contember/schema'
-import { assertNever } from '../utils'
+import { assertNever } from '../utils/index.js'
 
 namespace ValidationContext {
 	export type AnyContext = NodeContext | ValueContext | NodeListContext | UndefinedNodeContext

package/src/input-validation/ValidationDataSelector.ts

@@ -1,6 +1,6 @@
-import { QueryAstFactory } from './QueryAstFactory'
-import { Mapper } from '../mapper'
-import { Dependencies } from './dependencies'
+import { QueryAstFactory } from './QueryAstFactory.js'
+import { Mapper } from '../mapper/index.js'
+import { Dependencies } from './dependencies/index.js'
 import { Input, Model, Value } from '@contember/schema'
 
 export class ValidationDataSelector {

package/src/input-validation/ValidationEvaluation.ts

@@ -1,5 +1,5 @@
 import { Validation } from '@contember/schema'
-import { ValidationContext } from './ValidationContext'
+import { ValidationContext } from './ValidationContext.js'
 import acceptContextVisitor = ValidationContext.acceptContextVisitor
 import NodeContextType = ValidationContext.NodeContextType
 

package/src/input-validation/dependencies/DependencyCollector.ts

@@ -1,5 +1,5 @@
 import { Validation } from '@contember/schema'
-import { assertNever } from '../../utils'
+import { assertNever } from '../../utils/index.js'
 import { InputValidation } from '@contember/schema-definition'
 
 export class DependencyCollector {

package/src/input-validation/dependencies/DependencyMerger.ts

@@ -1,5 +1,5 @@
-import { tuple } from '../../utils'
-import { Dependencies } from './DependencyCollector'
+import { tuple } from '../../utils/index.js'
+import { Dependencies } from './DependencyCollector.js'
 
 export class DependencyMerger {
 	static merge(a: Dependencies, b: Dependencies): Dependencies {

package/src/input-validation/dependencies/index.ts

@@ -1,2 +1,2 @@
-export * from './DependencyCollector'
-export * from './DependencyMerger'
+export * from './DependencyCollector.js'
+export * from './DependencyMerger.js'