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

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'

package/src/input-validation/index.ts

@@ -1,11 +1,12 @@
-export * from './dependencies'
-export * from './preValidation'
-export * from './ColumnValueResolver'
-export * from './EntityRulesResolver'
-export * from './exceptions'
-export * from './InputValidator'
-export * from './QueryAstFactory'
-export * from './ValidationContext'
-export * from './ValidationDataSelector'
-export * from './ValidationEvaluation'
-export * from './ValidationPath'
+export * from './dependencies/index.js'
+export * from './preValidation/index.js'
+export * from './ColumnValueResolver.js'
+export * from './EntityRulesResolver.js'
+export * from './exceptions.js'
+export * from './InputValidator.js'
+export * from './JsonSchemaValidator.js'
+export * from './QueryAstFactory.js'
+export * from './ValidationContext.js'
+export * from './ValidationDataSelector.js'
+export * from './ValidationEvaluation.js'
+export * from './ValidationPath.js'

package/src/input-validation/preValidation/CreateInputPreValidationProcessor.ts

@@ -1,8 +1,8 @@
-import { CreateInputProcessor } from '../../inputProcessing'
+import { CreateInputProcessor } from '../../inputProcessing/index.js'
 import { Input, Model } from '@contember/schema'
-import { appendRelationToPath, ValidationPath } from '../ValidationPath'
-import { Mapper, MapperInput } from '../../mapper'
-import { InputPreValidator } from './InputPreValidator'
+import { appendRelationToPath, ValidationPath } from '../ValidationPath.js'
+import { Mapper, MapperInput } from '../../mapper/index.js'
+import { InputPreValidator } from './InputPreValidator.js'
 
 type Result = any
 const NoResult = () => Promise.resolve([])

package/src/input-validation/preValidation/InputPreValidator.ts

@@ -1,21 +1,22 @@
 import { acceptEveryFieldVisitor } from '@contember/schema-utils'
-import { isIt, tuple } from '../../utils'
+import { isIt, tuple } from '../../utils/index.js'
 import { Input, Model, Validation, Value } from '@contember/schema'
 import { InputValidation } from '@contember/schema-definition'
-import { CreateInputVisitor, UpdateInputVisitor } from '../../inputProcessing'
-import { CreateInputPreValidationProcessor } from './CreateInputPreValidationProcessor'
-import { ValidationContext } from '../ValidationContext'
-import { evaluateValidation } from '../ValidationEvaluation'
-import { ValidationPath } from '../ValidationPath'
-import { EntityRulesResolver } from '../EntityRulesResolver'
-import { FieldValidationResult, ValidationResult } from '../InputValidator'
-import { UpdateInputPreValidationProcessor } from './UpdateInputPreValidationProcessor'
-import { ColumnValueResolver } from '../ColumnValueResolver'
-import { Mapper, MapperInput } from '../../mapper'
-import { Dependencies, DependencyCollector } from '../dependencies'
-import { DependencyMerger } from '../dependencies'
-import { NotSupportedError } from '../exceptions'
-import { ValidationDataSelector } from '../ValidationDataSelector'
+import { CreateInputVisitor, UpdateInputVisitor } from '../../inputProcessing/index.js'
+import { CreateInputPreValidationProcessor } from './CreateInputPreValidationProcessor.js'
+import { ValidationContext } from '../ValidationContext.js'
+import { evaluateValidation } from '../ValidationEvaluation.js'
+import { ValidationPath } from '../ValidationPath.js'
+import { EntityRulesResolver } from '../EntityRulesResolver.js'
+import { FieldValidationResult, ValidationResult } from '../InputValidator.js'
+import { UpdateInputPreValidationProcessor } from './UpdateInputPreValidationProcessor.js'
+import { ColumnValueResolver } from '../ColumnValueResolver.js'
+import { Mapper, MapperInput } from '../../mapper/index.js'
+import { Dependencies, DependencyCollector } from '../dependencies/index.js'
+import { DependencyMerger } from '../dependencies/index.js'
+import { NotSupportedError } from '../exceptions.js'
+import { ValidationDataSelector } from '../ValidationDataSelector.js'
+import { validateJsonSchema } from '../JsonSchemaValidator.js'
 
 export interface CreateValidationArgs {
 	mapper: Mapper
@@ -54,11 +55,13 @@ export class InputPreValidator {
 
 		const fieldsResult = this.validateFields(rules, context, path)
 
+		const jsonSchemaResult = this.validateJsonSchemaColumns(entity, data, path)
+
 		const processor = new CreateInputPreValidationProcessor(this, path, mapper)
 		const visitor = new CreateInputVisitor(processor, this.model, data)
 		const relationResult = await this.validateRelations(entity, visitor)
 
-		return [...fieldsResult, ...relationResult]
+		return [...fieldsResult, ...jsonSchemaResult, ...relationResult]
 	}
 
 	async validateUpdate({ entity, data, path, mapper, where }: UpdateValidationArgs): Promise<ValidationResult> {
@@ -69,11 +72,51 @@ export class InputPreValidator {
 		const context = await this.createContextForUpdate(mapper, entity, where, data, dependencies)
 		const fieldsResult: ValidationResult = this.validateFields(rules, context, path)
 
+		const jsonSchemaResult = this.validateJsonSchemaColumns(entity, data, path)
+
 		const processor = new UpdateInputPreValidationProcessor(this, path, mapper)
 		const visitor = new UpdateInputVisitor(processor, this.model, data)
 		const relationResult = await this.validateRelations(entity, visitor)
 
-		return [...fieldsResult, ...relationResult]
+		return [...fieldsResult, ...jsonSchemaResult, ...relationResult]
+	}
+
+	/**
+	 * Validates JSON columns that have a JSON Schema attached. Only fields present in the input
+	 * are validated; `null` values are skipped (use `notNull()` to forbid them).
+	 */
+	private validateJsonSchemaColumns(
+		entity: Model.Entity,
+		data: MapperInput.CreateDataInput | MapperInput.UpdateDataInput,
+		path: ValidationPath,
+	): ValidationResult {
+		const result: ValidationResult = []
+		for (const field of Object.values(entity.fields)) {
+			if (field.type !== Model.ColumnType.Json) {
+				continue
+			}
+			const schema = (field as Model.AnyColumn).schema
+			if (schema === undefined) {
+				continue
+			}
+			if (!(field.name in data)) {
+				continue
+			}
+			const value = data[field.name] as Input.ColumnValue
+			if (value === null || value === undefined) {
+				continue
+			}
+			const errors = validateJsonSchema(schema, value)
+			for (const error of errors) {
+				result.push({
+					path: [...path, { field: field.name }],
+					message: {
+						text: error.path ? `${error.path}: ${error.message}` : error.message,
+					},
+				})
+			}
+		}
+		return result
 	}
 
 	private createContextForCreate(entity: Model.Entity, data: MapperInput.CreateDataInput): ValidationContext.NodeContext {

package/src/input-validation/preValidation/UpdateInputPreValidationProcessor.ts

@@ -1,8 +1,8 @@
-import { UpdateInputProcessor } from '../../inputProcessing'
+import { UpdateInputProcessor } from '../../inputProcessing/index.js'
 import { Input, Model } from '@contember/schema'
-import { appendRelationToPath, ValidationPath } from '../ValidationPath'
-import { Mapper, MapperInput } from '../../mapper'
-import { InputPreValidator } from './InputPreValidator'
+import { appendRelationToPath, ValidationPath } from '../ValidationPath.js'
+import { Mapper, MapperInput } from '../../mapper/index.js'
+import { InputPreValidator } from './InputPreValidator.js'
 
 type Result = any
 

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

@@ -1,3 +1,3 @@
-export * from './CreateInputPreValidationProcessor'
-export * from './InputPreValidator'
-export * from './UpdateInputPreValidationProcessor'
+export * from './CreateInputPreValidationProcessor.js'
+export * from './InputPreValidator.js'
+export * from './UpdateInputPreValidationProcessor.js'

package/src/inputProcessing/CreateInputProcessor.ts

@@ -1,6 +1,6 @@
 import { Input, Model } from '@contember/schema'
-import { CheckedPrimary } from '../mapper/CheckedPrimary'
-import { MapperInput } from '../mapper'
+import { CheckedPrimary } from '../mapper/CheckedPrimary.js'
+import { MapperInput } from '../mapper/index.js'
 
 interface CreateInputProcessor<Result = void> {
 	column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<Result>

package/src/inputProcessing/CreateInputVisitor.ts

@@ -1,8 +1,8 @@
-import { filterObject } from '../utils'
+import { filterObject } from '../utils/index.js'
 import { Input, Model } from '@contember/schema'
-import { CreateInputProcessor } from './CreateInputProcessor'
-import { ImplementationException, UserError } from '../exception'
-import { MapperInput } from '../mapper'
+import { CreateInputProcessor } from './CreateInputProcessor.js'
+import { ImplementationException, UserError } from '../exception.js'
+import { MapperInput } from '../mapper/index.js'
 
 export class CreateInputVisitor<Result> implements Model.ColumnVisitor<Promise<Result[]>>, Model.RelationByTypeVisitor<Promise<Result[]>> {
 	constructor(

package/src/inputProcessing/ObjectNode.ts

@@ -1,4 +1,4 @@
-import { FieldNode } from './FieldNode'
+import { FieldNode } from './FieldNode.js'
 
 export class ObjectNode<Args = any, Extensions extends Record<string, any> = Record<string, any>> {
 	constructor(

package/src/inputProcessing/UniqueWhereExpander.ts

@@ -1,8 +1,8 @@
 import { Input, Model, Writable } from '@contember/schema'
 import { getTargetEntity } from '@contember/schema-utils'
-import { UserError } from '../exception'
-import { getFieldsForUniqueWhere } from '../utils'
-import { CheckedPrimary } from '../mapper/CheckedPrimary'
+import { UserError } from '../exception.js'
+import { getFieldsForUniqueWhere } from '../utils/index.js'
+import { CheckedPrimary } from '../mapper/CheckedPrimary.js'
 
 type ExtendedUniqueWhere = Input.UniqueWhere<Input.PrimaryValue[]>
 

package/src/inputProcessing/UpdateInputProcessor.ts

@@ -1,6 +1,6 @@
 import { Input, Model } from '@contember/schema'
-import { CheckedPrimary } from '../mapper/CheckedPrimary'
-import { MapperInput } from '../mapper'
+import { CheckedPrimary } from '../mapper/CheckedPrimary.js'
+import { MapperInput } from '../mapper/index.js'
 
 interface UpdateInputProcessor<Result = void> {
 	column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<Result>

package/src/inputProcessing/UpdateInputVisitor.ts

@@ -1,8 +1,8 @@
 import { Input, Model } from '@contember/schema'
-import { filterObject } from '../utils'
-import { UpdateInputProcessor } from './UpdateInputProcessor'
-import { ImplementationException, UserError } from '../exception'
-import { MapperInput } from '../mapper'
+import { filterObject } from '../utils/index.js'
+import { UpdateInputProcessor } from './UpdateInputProcessor.js'
+import { ImplementationException, UserError } from '../exception.js'
+import { MapperInput } from '../mapper/index.js'
 
 export class UpdateInputVisitor<Result> implements Model.ColumnVisitor<Promise<Result[]>>, Model.RelationByTypeVisitor<Promise<Result[]>> {
 	constructor(

package/src/inputProcessing/index.ts

@@ -1,7 +1,7 @@
-export * from './CreateInputProcessor'
-export * from './CreateInputVisitor'
-export * from './FieldNode'
-export * from './ObjectNode'
-export * from './UniqueWhereExpander'
-export * from './UpdateInputProcessor'
-export * from './UpdateInputVisitor'
+export * from './CreateInputProcessor.js'
+export * from './CreateInputVisitor.js'
+export * from './FieldNode.js'
+export * from './ObjectNode.js'
+export * from './UniqueWhereExpander.js'
+export * from './UpdateInputProcessor.js'
+export * from './UpdateInputVisitor.js'

package/src/introspection/IntrospectionSchemaDefinitionFactory.ts

@@ -1,7 +1,7 @@
 import { GraphQLSchema, GraphQLSchemaConfig } from 'graphql'
-import * as ContentSchema from './content-schema.types'
-import { IntrospectionSchemaFactory } from './IntrospectionSchemaFactory'
-import { createSchemaConfig } from './introspection.schema'
+import * as ContentSchema from './content-schema.types.js'
+import { IntrospectionSchemaFactory } from './IntrospectionSchemaFactory.js'
+import { createSchemaConfig } from './introspection.schema.js'
 
 export class IntrospectionSchemaDefinitionFactory {
 	constructor(private readonly introspectionSchemaFactory: IntrospectionSchemaFactory) {}

package/src/introspection/IntrospectionSchemaFactory.ts

@@ -1,8 +1,8 @@
 import { Acl, Model, Validation } from '@contember/schema'
-import { EntityRulesResolver } from '../input-validation'
-import { Authorizator } from '../acl'
-import * as ContentSchema from './content-schema.types'
-import { assertNever } from '../utils'
+import { EntityRulesResolver } from '../input-validation/index.js'
+import { Authorizator } from '../acl/index.js'
+import * as ContentSchema from './content-schema.types.js'
+import { assertNever } from '../utils/index.js'
 import { acceptEveryFieldVisitor, getEntity } from '@contember/schema-utils'
 
 type AdditionalFieldInfo =

package/src/introspection/index.ts

@@ -1,4 +1,4 @@
-export * as ContentSchemaTypes from './content-schema.types'
-export { IntrospectionSchemaDefinitionFactory } from './IntrospectionSchemaDefinitionFactory'
-export { default as ContentSchema } from './introspection.schema'
-export * from './IntrospectionSchemaFactory'
+export * as ContentSchemaTypes from './content-schema.types.js'
+export { IntrospectionSchemaDefinitionFactory } from './IntrospectionSchemaDefinitionFactory.js'
+export { default as ContentSchema } from './introspection.schema.js'
+export * from './IntrospectionSchemaFactory.js'

package/src/mapper/ErrorUtils.ts

@@ -7,9 +7,9 @@ import {
 	MutationResultHint,
 	MutationResultList,
 	MutationSqlError,
-} from './Result'
+} from './Result.js'
 import * as Database from '@contember/database'
-import { UniqueWhereError } from '../inputProcessing'
+import { UniqueWhereError } from '../inputProcessing/index.js'
 import { Model } from '@contember/schema'
 import { acceptFieldVisitor, tryGetColumnName } from '@contember/schema-utils'
 import { logger } from '@contember/logger'

package/src/mapper/EventManager.ts

@@ -1,6 +1,6 @@
 import { Input, Model, Value } from '@contember/schema'
-import { Mapper } from './Mapper'
-import { ColumnValue } from './ColumnValue'
+import { Mapper } from './Mapper.js'
+import { ColumnValue } from './ColumnValue.js'
 
 export class BeforeInsertEvent {
 	public type = 'BeforeInsertEvent' as const