@contember/schema-utils 2.1.0-beta.2 → 2.2.0-alpha.2

package/src/json-schema/jsonSchemaToTsType.ts

@@ -0,0 +1,188 @@
+import { JSONValue } from '@contember/schema'
+
+/**
+ * The TypeScript type emitted when a JSON Schema (or a subschema) cannot be faithfully expressed.
+ * It is the universal JSON supertype, so falling back to it is always sound — never looser than the
+ * actual data could be, just less precise.
+ */
+export const JSON_VALUE_TYPE = 'JSONValue'
+
+const isPlainObject = (value: JSONValue): value is { readonly [key: string]: JSONValue } =>
+	typeof value === 'object' && value !== null && !Array.isArray(value)
+
+const isPrimitive = (value: JSONValue): value is string | number | boolean | null =>
+	value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+
+const literal = (value: string | number | boolean | null): string => {
+	if (value === null) {
+		return 'null'
+	}
+	if (typeof value === 'string') {
+		return JSON.stringify(value)
+	}
+	return String(value)
+}
+
+const VALID_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/
+
+const propertyKey = (key: string): string => (VALID_IDENTIFIER.test(key) ? key : JSON.stringify(key))
+
+/**
+ * Derives a TypeScript type from the {@link SUPPORTED_JSON_SCHEMA_KEYWORDS supported subset} of JSON
+ * Schema. For any construct it cannot faithfully and soundly express it returns {@link JSON_VALUE_TYPE},
+ * never a type that is wider than the data could actually be.
+ *
+ * Mapping:
+ * - `const` (primitive) / `enum` (primitives) → literal / union of literals
+ * - `type` scalar: string → `string`, number|integer → `number`, boolean → `boolean`, null → `null`
+ * - `type: 'object'` (+ `properties`/`required`) → object type with optional vs required props
+ * - `type: 'array'` (+ `items`) → `T[]`
+ * - `type` array → union of the per-type results
+ * - `allOf` → intersection, `anyOf`/`oneOf` → union
+ *
+ * A boolean schema, an empty schema, or anything not covered → `JSONValue`.
+ */
+export const jsonSchemaToTsType = (schema: JSONValue): string => {
+	const result = derive(schema)
+	return result ?? JSON_VALUE_TYPE
+}
+
+/** Returns the derived type, or `null` if it must fall back to {@link JSON_VALUE_TYPE}. */
+const derive = (schema: JSONValue): string | null => {
+	if (!isPlainObject(schema)) {
+		// boolean schema (`true`/`false`) – not faithfully expressible / not a constraint we model
+		return null
+	}
+
+	// const – only primitives are faithfully expressible as a literal
+	if ('const' in schema && schema.const !== undefined) {
+		return isPrimitive(schema.const) ? literal(schema.const) : null
+	}
+
+	// enum – union of primitive literals
+	if (Array.isArray(schema.enum)) {
+		if (schema.enum.length === 0 || !schema.enum.every(isPrimitive)) {
+			return null
+		}
+		return union(schema.enum.map(it => literal(it as string | number | boolean | null)))
+	}
+
+	// combinators (independent of `type`)
+	if (Array.isArray(schema.allOf)) {
+		const parts = mapAll(schema.allOf)
+		return parts && parts.length > 0 ? intersection(parts) : null
+	}
+	if (Array.isArray(schema.anyOf)) {
+		const parts = mapAll(schema.anyOf)
+		return parts && parts.length > 0 ? union(parts) : null
+	}
+	if (Array.isArray(schema.oneOf)) {
+		const parts = mapAll(schema.oneOf)
+		return parts && parts.length > 0 ? union(parts) : null
+	}
+	// `not` is not expressible as a positive TS type
+	if ('not' in schema) {
+		return null
+	}
+
+	if (schema.type !== undefined) {
+		return deriveFromType(schema)
+	}
+
+	// no recognized type-narrowing keyword → cannot tighten below JSONValue
+	return null
+}
+
+const deriveFromType = (schema: { readonly [key: string]: JSONValue }): string | null => {
+	const types = Array.isArray(schema.type) ? schema.type : [schema.type]
+	const parts: string[] = []
+	for (const type of types) {
+		const part = deriveScalarOrContainer(type, schema)
+		if (part === null) {
+			return null
+		}
+		parts.push(part)
+	}
+	return parts.length > 0 ? union(parts) : null
+}
+
+const deriveScalarOrContainer = (type: JSONValue, schema: { readonly [key: string]: JSONValue }): string | null => {
+	switch (type) {
+		case 'string':
+			return 'string'
+		case 'number':
+		case 'integer':
+			return 'number'
+		case 'boolean':
+			return 'boolean'
+		case 'null':
+			return 'null'
+		case 'array':
+			return deriveArray(schema)
+		case 'object':
+			return deriveObject(schema)
+		default:
+			return null
+	}
+}
+
+const deriveArray = (schema: { readonly [key: string]: JSONValue }): string | null => {
+	const items = schema.items
+	if (items === undefined) {
+		// array of unknown element type
+		return `readonly ${JSON_VALUE_TYPE}[]`
+	}
+	if (Array.isArray(items)) {
+		// tuple form (`items` as array) is not part of the supported subset
+		return null
+	}
+	const itemType = derive(items) ?? JSON_VALUE_TYPE
+	return `readonly (${itemType})[]`
+}
+
+const deriveObject = (schema: { readonly [key: string]: JSONValue }): string | null => {
+	const properties = schema.properties
+	if (!isPlainObject(properties) || Object.keys(properties).length === 0) {
+		// closed/open object with no declared properties – stay sound, do not emit `{}`
+		return null
+	}
+	const requiredList = Array.isArray(schema.required) ? schema.required.filter((it): it is string => typeof it === 'string') : []
+	const required = new Set<string>(requiredList)
+	const members: string[] = []
+	for (const key of Object.keys(properties)) {
+		const propType = derive(properties[key]) ?? JSON_VALUE_TYPE
+		const optional = required.has(key) ? '' : '?'
+		members.push(`${propertyKey(key)}${optional}: ${propType}`)
+	}
+	return `{ ${members.join('; ')} }`
+}
+
+const mapAll = (schemas: readonly JSONValue[]): string[] | null => {
+	const parts: string[] = []
+	for (const sub of schemas) {
+		const part = derive(sub)
+		if (part === null) {
+			return null
+		}
+		parts.push(part)
+	}
+	return parts
+}
+
+const union = (parts: readonly string[]): string => {
+	const unique = [...new Set(parts)]
+	return unique.length === 1 ? unique[0] : unique.map(wrapForUnion).join(' | ')
+}
+
+const intersection = (parts: readonly string[]): string => {
+	const unique = [...new Set(parts)]
+	return unique.length === 1 ? unique[0] : unique.map(wrapForUnion).join(' & ')
+}
+
+/** Wrap composite types in parentheses so unions/intersections compose unambiguously. */
+const wrapForUnion = (type: string): string => {
+	if (type.includes(' | ') || type.includes(' & ')) {
+		return `(${type})`
+	}
+	return type
+}

package/src/json-schema/keywords.ts

@@ -0,0 +1,79 @@
+/**
+ * The single source of truth for the JSON Schema subset Contember supports on a
+ * {@link Model.ColumnType.Json} column.
+ *
+ * Three independent consumers MUST agree on this set:
+ * - the runtime input validator (`@contember/engine-content-api` `validateJsonSchema`),
+ * - the schema-build keyword check ({@link collectUnsupportedJsonSchemaKeywords}, wired into
+ *   `ModelValidator`),
+ * - the generated-client type derivation (`@contember/client-content-generator` `jsonSchemaToTsType`).
+ *
+ * Keep this list in sync with the keywords actually honored by the validator. Adding a keyword here
+ * without also implementing it in the validator would make the schema-build check accept a schema the
+ * runtime silently ignores — exactly the bug this set exists to prevent.
+ */
+export const SUPPORTED_JSON_SCHEMA_KEYWORDS = [
+	// generic
+	'type',
+	'enum',
+	'const',
+	// object
+	'properties',
+	'required',
+	'additionalProperties',
+	'minProperties',
+	'maxProperties',
+	// array (draft-07 style `items` applied to all elements)
+	'items',
+	'minItems',
+	'maxItems',
+	'uniqueItems',
+	// string
+	'minLength',
+	'maxLength',
+	'pattern',
+	// number
+	'minimum',
+	'maximum',
+	'exclusiveMinimum',
+	'exclusiveMaximum',
+	'multipleOf',
+	// combinators
+	'allOf',
+	'anyOf',
+	'oneOf',
+	'not',
+] as const
+
+export type SupportedJsonSchemaKeyword = (typeof SUPPORTED_JSON_SCHEMA_KEYWORDS)[number]
+
+/**
+ * Non-validating annotation/metadata keywords. They have no effect on validation but are explicitly
+ * allowed in a supplied schema so that documentation, defaults and authoring hints do not trigger a
+ * "unsupported keyword" schema error.
+ */
+export const ALLOWED_JSON_SCHEMA_ANNOTATION_KEYWORDS = [
+	'title',
+	'description',
+	'$schema',
+	'$id',
+	'$comment',
+	'examples',
+	'default',
+	'readOnly',
+	'writeOnly',
+	'deprecated',
+] as const
+
+export type AllowedJsonSchemaAnnotationKeyword = (typeof ALLOWED_JSON_SCHEMA_ANNOTATION_KEYWORDS)[number]
+
+const supportedKeywordSet: ReadonlySet<string> = new Set<string>(SUPPORTED_JSON_SCHEMA_KEYWORDS)
+const annotationKeywordSet: ReadonlySet<string> = new Set<string>(ALLOWED_JSON_SCHEMA_ANNOTATION_KEYWORDS)
+
+export const isSupportedJsonSchemaKeyword = (keyword: string): keyword is SupportedJsonSchemaKeyword => supportedKeywordSet.has(keyword)
+
+export const isAllowedJsonSchemaAnnotationKeyword = (keyword: string): keyword is AllowedJsonSchemaAnnotationKeyword =>
+	annotationKeywordSet.has(keyword)
+
+/** A keyword is recognized if it is either a supported validation keyword or an allowed annotation. */
+export const isRecognizedJsonSchemaKeyword = (keyword: string): boolean => supportedKeywordSet.has(keyword) || annotationKeywordSet.has(keyword)

package/src/lax/LaxSchemaConverter.ts

@@ -1,7 +1,7 @@
 import { Model, Schema, Writable } from '@contember/schema'
-import { LaxSchema, LaxSchemaColumn, LaxSchemaEnum, LaxSchemaField, LaxSchemaRelation } from './schema'
-import { DefaultNamingConventions, NamingConventions, resolveDefaultColumnType } from '../model'
-import { emptySchema } from '../index'
+import { LaxSchema, LaxSchemaColumn, LaxSchemaEnum, LaxSchemaField, LaxSchemaRelation } from './schema.js'
+import { DefaultNamingConventions, NamingConventions, resolveDefaultColumnType } from '../model/index.js'
+import { emptySchema } from '../index.js'
 
 const simpleColumnTypes: { [K in LaxSchemaColumn['type']]: { type: Model.ColumnType; columnType: string } } = {
 	boolean: { type: Model.ColumnType.Bool, columnType: 'boolean' },

package/src/lax/index.ts

@@ -1,2 +1,2 @@
-export * from './schema'
-export { LaxSchemaConverter } from './LaxSchemaConverter'
+export * from './schema.js'
+export { LaxSchemaConverter } from './LaxSchemaConverter.js'

package/src/model/index.ts

@@ -1,3 +1,3 @@
-export * from './modelUtils'
-export * from './resolveDefaultColumnType'
-export * from './NamingConventions'
+export * from './modelUtils.js'
+export * from './resolveDefaultColumnType.js'
+export * from './NamingConventions.js'

package/src/model/modelUtils.ts

@@ -1,4 +1,4 @@
-import { assertNever, isIt } from '../utils'
+import { assertNever, isIt } from '../utils/index.js'
 import { Model } from '@contember/schema'
 
 export enum ModelErrorCode {

package/src/model/resolveDefaultColumnType.ts

@@ -1,5 +1,5 @@
 import { Model } from '@contember/schema'
-import { assertNever } from '../utils'
+import { assertNever } from '../utils/index.js'
 
 export const resolveDefaultColumnType = (type: Exclude<Model.ColumnType, Model.ColumnType.Enum>): string => {
 	switch (type) {
@@ -7,6 +7,8 @@ export const resolveDefaultColumnType = (type: Exclude<Model.ColumnType, Model.C
 			return 'integer'
 		case Model.ColumnType.Double:
 			return 'double precision'
+		case Model.ColumnType.Numeric:
+			return 'numeric'
 		case Model.ColumnType.String:
 			return 'text'
 		case Model.ColumnType.Uuid:

package/src/schemaNormalizer.ts

@@ -1,5 +1,5 @@
 import { Acl, ProjectRole, Schema } from '@contember/schema'
-import { AllowAllPermissionFactory } from './acl'
+import { AllowAllPermissionFactory } from './acl/index.js'
 
 export const normalizeSchema = <S extends Schema>(schema: S): S => {
 	const adminRoleDefinition: Partial<Acl.RolePermissions> = schema.acl.roles?.[ProjectRole.ADMIN] ?? {}

package/src/type-schema/acl.ts

@@ -1,6 +1,6 @@
 import { Acl, Model } from '@contember/schema'
 import * as Typesafe from '@contember/typesafe'
-import { conditionSchema } from './condition'
+import { conditionSchema } from './condition.js'
 
 const membershipMatchRuleSchema = Typesafe.union(
 	Typesafe.boolean,

package/src/type-schema/condition.ts

@@ -48,6 +48,8 @@ const conditionSchemaInner = <T extends Json>(metadata: ResolvedColumnMetadata<T
 					containsCI: Typesafe.string,
 					startsWithCI: Typesafe.string,
 					endsWithCI: Typesafe.string,
+					similar: Typesafe.string,
+					wordSimilar: Typesafe.string,
 				}
 				: {}),
 		}))
@@ -77,6 +79,9 @@ const resolveColumnTypeSchema = (type: Model.ColumnType) => {
 		case Model.ColumnType.Enum:
 		case Model.ColumnType.String:
 			return Typesafe.string
+		// Numeric is transported as a string to avoid JS float precision loss.
+		case Model.ColumnType.Numeric:
+			return Typesafe.string
 		case Model.ColumnType.Double:
 			return Typesafe.number
 		case Model.ColumnType.Int:

package/src/type-schema/index.ts

@@ -1,5 +1,5 @@
-export * from './acl'
-export * from './condition'
-export * from './model'
-export * from './settings'
-export * from './validation'
+export * from './acl.js'
+export * from './condition.js'
+export * from './model.js'
+export * from './settings.js'
+export * from './validation.js'

package/src/type-schema/model.ts

@@ -138,6 +138,7 @@ const columnSchema = Typesafe.intersection(
 		default: Typesafe.anyJson,
 		sequence: intersectionSchema as Typesafe.Type<Model.AnyColumn['sequence']>,
 		collation: Typesafe.string as Typesafe.Type<Model.AnyColumn['collation']>,
+		schema: Typesafe.anyJson,
 	}),
 )
 const columnSchemaCheck: Typesafe.Equals<Model.AnyColumn, ReturnType<typeof columnSchema>> = true
@@ -173,6 +174,17 @@ const indexSchemaBase = Typesafe.intersection(
 	Typesafe.partial({
 		name: Typesafe.string,
 		method: Typesafe.enumeration('btree', 'gin', 'gist', 'hash', 'brin', 'spgist'),
+		opClass: Typesafe.string,
+		where: Typesafe.string,
+		include: Typesafe.array(Typesafe.string),
+		columnOptions: Typesafe.record(
+			Typesafe.string,
+			Typesafe.partial({
+				order: Typesafe.enumeration('asc', 'desc'),
+				nulls: Typesafe.enumeration('first', 'last'),
+				opClass: Typesafe.string,
+			}),
+		),
 	}),
 )
 const indexCheck: Typesafe.Equals<Model.Index, ReturnType<typeof indexSchemaBase>> = true

package/src/type-schema/settings.ts

@@ -10,6 +10,7 @@ export const settingsSchema = Typesafe.partial({
 	content: Typesafe.partial({
 		useExistsInHasManyFilter: Typesafe.boolean,
 		fullDateTimeResponse: Typesafe.boolean,
+		dateTimeResponseFormat: Typesafe.union(Typesafe.literal('legacy'), Typesafe.literal('iso8601')),
 		shortDateResponse: Typesafe.boolean,
 		uuidVersion: Typesafe.union(Typesafe.literal(4), Typesafe.literal(7)),
 	}),

package/src/type-schema/where.ts

@@ -1,6 +1,6 @@
 import { Input, Model } from '@contember/schema'
-import { acceptFieldVisitor } from '../model'
-import { conditionSchema } from './condition'
+import { acceptFieldVisitor } from '../model/index.js'
+import { conditionSchema } from './condition.js'
 import * as Typesafe from '@contember/typesafe'
 
 export const whereSchema = ({ schema, entity }: {

package/src/utils/index.ts

@@ -1,3 +1,3 @@
-export * from './assertNever'
-export * from './isIt'
-export * from './deepCompare'
+export * from './assertNever.js'
+export * from './isIt.js'
+export * from './deepCompare.js'

package/src/validation/AclValidator.ts

@@ -1,8 +1,8 @@
 import { Acl, Model } from '@contember/schema'
-import { PredicateDefinitionProcessor } from '../acl'
-import { getEntity } from '../model'
-import { ErrorBuilder, ValidationError } from './errors'
-import { conditionSchema } from '../type-schema'
+import { PredicateDefinitionProcessor } from '../acl/index.js'
+import { getEntity } from '../model/index.js'
+import { ErrorBuilder, ValidationError } from './errors.js'
+import { conditionSchema } from '../type-schema/index.js'
 
 export class AclValidator {
 	constructor(private readonly model: Model.Schema) {}

package/src/validation/ActionsValidator.ts

@@ -1,9 +1,9 @@
 import { Actions, Model } from '@contember/schema'
-import { acceptFieldVisitor } from '../model'
-import { ErrorBuilder, ValidationError } from './errors'
-import { assertNever } from '../utils'
+import { acceptFieldVisitor } from '../model/index.js'
+import { ErrorBuilder, ValidationError } from './errors.js'
+import { assertNever } from '../utils/index.js'
 import * as Typesafe from '@contember/typesafe'
-import { whereSchema } from '../type-schema/where'
+import { whereSchema } from '../type-schema/where.js'
 
 const manyArgsSchema = (args: { schema: Model.Schema; entity: Model.Entity }) =>
 	Typesafe.partial({

package/src/validation/MembershipResolver.ts

@@ -1,7 +1,7 @@
 import { Acl, Input } from '@contember/schema'
-import { getRoleVariables } from '../acl'
-import { conditionSchema } from '../type-schema'
-import { assertNever } from '../utils'
+import { getRoleVariables } from '../acl/index.js'
+import { conditionSchema } from '../type-schema/index.js'
+import { assertNever } from '../utils/index.js'
 
 export class MembershipResolver {
 	public static UnknownIdentity = { identityId: '00000000-0000-0000-0000-000000000000' }

package/src/validation/ModelValidator.ts

@@ -1,8 +1,11 @@
 import { Model } from '@contember/schema'
-import { ErrorBuilder, ValidationError } from './errors'
-import { acceptEveryFieldVisitor, getTargetEntity, isColumn, isInverseRelation, isOwningRelation } from '../model'
+import { ErrorBuilder, ValidationError } from './errors.js'
+import { acceptEveryFieldVisitor, getTargetEntity, isColumn, isInverseRelation, isOwningRelation } from '../model/index.js'
+import { collectUnsupportedJsonSchemaKeywords, SUPPORTED_JSON_SCHEMA_KEYWORDS } from '../json-schema/index.js'
 
 const IDENTIFIER_PATTERN = /^[_a-zA-Z][_a-zA-Z0-9]*$/
+// An index operator class is an identifier, optionally schema-qualified (e.g. "public.gin_trgm_ops").
+const INDEX_OPCLASS_PATTERN = /^[_a-zA-Z][_a-zA-Z0-9$]*(\.[_a-zA-Z][_a-zA-Z0-9$]*)?$/
 const RESERVED_WORDS = ['and', 'or', 'not']
 
 export class ModelValidator {
@@ -54,9 +57,69 @@ export class ModelValidator {
 			entity,
 			errors.for('unique'),
 		)
+		this.validateIndexes(
+			entity,
+			errors.for('indexes'),
+		)
 		this.validateColumnNamesCollision(entity, errors)
 	}
 
+	private validateIndexes(entity: Model.Entity, errors: ErrorBuilder): void {
+		for (const index of entity.indexes) {
+			for (const field of [...index.fields, ...index.include ?? []]) {
+				if (!entity.fields[field]) {
+					errors.add('MODEL_UNDEFINED_FIELD', `Referenced field ${field} in an index does not exists`)
+				}
+			}
+			// Postgres rejects an INCLUDE column that is already a key column.
+			for (const field of index.include ?? []) {
+				if (index.fields.includes(field)) {
+					errors.add('MODEL_INVALID_INDEX', `Field ${field} cannot be both an index key and an included (covering) column`)
+				}
+			}
+			// Per-column options (order/nulls/opClass) only apply to key columns.
+			for (const field of Object.keys(index.columnOptions ?? {})) {
+				if (!index.fields.includes(field)) {
+					errors.add('MODEL_INVALID_INDEX', `Column options reference field ${field}, which is not a key column of the index`)
+				}
+			}
+			// columnOptions is keyed by field name, so a key column appearing twice cannot carry distinct
+			// per-position options (the duplicate collapses to one entry) — reject the ambiguous shape.
+			const seenFields = new Set<string>()
+			for (const field of index.fields) {
+				if (seenFields.has(field)) {
+					errors.add('MODEL_INVALID_INDEX', `Field ${field} is listed more than once as an index key column`)
+				}
+				seenFields.add(field)
+			}
+			// Sort order and NULLS placement are btree-only; Postgres rejects them on other methods at apply time.
+			if (index.method !== undefined && index.method !== 'btree') {
+				for (const [field, options] of Object.entries(index.columnOptions ?? {})) {
+					if (options.order !== undefined || options.nulls !== undefined) {
+						errors.add('MODEL_INVALID_INDEX', `Column options (order/nulls) on field ${field} are only supported for btree indexes, not "${index.method}"`)
+					}
+				}
+			}
+			// opClass is emitted verbatim into CREATE INDEX, so constrain it to an identifier (optionally
+			// schema-qualified) — both to block SQL injection and to catch typos early with a clear message.
+			for (const opClass of [index.opClass, ...Object.values(index.columnOptions ?? {}).map(it => it.opClass)]) {
+				if (opClass !== undefined && !INDEX_OPCLASS_PATTERN.test(opClass)) {
+					errors.add(
+						'MODEL_INVALID_INDEX',
+						`Invalid index operator class "${opClass}": expected an identifier, optionally schema-qualified (e.g. "public.gin_trgm_ops")`,
+					)
+				}
+			}
+			// `where` is a raw SQL predicate embedded verbatim into CREATE INDEX. We don't parse SQL,
+			// but a couple of basic checks catch the common footguns early with a clear message:
+			if (index.where !== undefined && index.where.trim() === '') {
+				errors.add('MODEL_INVALID_INDEX', 'Index predicate (where) must not be empty.')
+			} else if (index.where?.includes(';')) {
+				errors.add('MODEL_INVALID_INDEX', 'Index predicate (where) must not contain ";".')
+			}
+		}
+	}
+
 	private validateUniqueConstraints(entity: Model.Entity, errors: ErrorBuilder): void {
 		for (const constraint of entity.unique) {
 			if (entity.view?.materialized && !constraint.index) {
@@ -109,6 +172,21 @@ export class ModelValidator {
 			if (field.sequence && field.nullable) {
 				errors.add('MODEL_INVALID_COLUMN_DEFINITION', 'Column with sequence cannot be nullable.')
 			}
+			this.validateColumnJsonSchema(field, errors)
+		}
+	}
+
+	private validateColumnJsonSchema(column: Model.AnyColumn, errors: ErrorBuilder): void {
+		if (column.type !== Model.ColumnType.Json || column.schema === undefined) {
+			return
+		}
+		for (const { keyword, path } of collectUnsupportedJsonSchemaKeywords(column.schema)) {
+			const location = path === '' ? 'at the schema root' : `at "${path}"`
+			errors.add(
+				'MODEL_INVALID_JSON_SCHEMA',
+				`JSON Schema on column "${column.name}" uses unsupported keyword "${keyword}" ${location}. `
+					+ `Only the following keywords are supported: ${SUPPORTED_JSON_SCHEMA_KEYWORDS.join(', ')}.`,
+			)
 		}
 	}
 

package/src/validation/SchemaValidator.ts

@@ -1,9 +1,9 @@
 import { Schema } from '@contember/schema'
-import { ValidationError, ValidationErrorCode } from './errors'
-import { AclValidator } from './AclValidator'
-import { ModelValidator } from './ModelValidator'
-import { ValidationValidator } from './ValidationValidator'
-import { ActionsValidator } from './ActionsValidator'
+import { ValidationError, ValidationErrorCode } from './errors.js'
+import { AclValidator } from './AclValidator.js'
+import { ModelValidator } from './ModelValidator.js'
+import { ValidationValidator } from './ValidationValidator.js'
+import { ActionsValidator } from './ActionsValidator.js'
 
 export interface SchemaValidatorSkippedErrors {
 	readonly code: ValidationErrorCode

package/src/validation/ValidationValidator.ts

@@ -1,6 +1,6 @@
 import { Model, Validation } from '@contember/schema'
-import { ErrorBuilder, ValidationError } from './errors'
-import { acceptFieldVisitor } from '../model'
+import { ErrorBuilder, ValidationError } from './errors.js'
+import { acceptFieldVisitor } from '../model/index.js'
 
 export class ValidationValidator {
 	constructor(private readonly model: Model.Schema) {}

package/src/validation/errors.ts

@@ -6,10 +6,12 @@ export type ValidationErrorCode =
 	| 'MODEL_RELATION_REQUIRED'
 	| 'MODEL_INVALID_RELATION_DEFINITION'
 	| 'MODEL_INVALID_COLUMN_DEFINITION'
+	| 'MODEL_INVALID_JSON_SCHEMA'
 	| 'MODEL_INVALID_VIEW_USAGE'
 	| 'MODEL_INVALID_IDENTIFIER'
 	| 'MODEL_INVALID_ENTITY_NAME'
 	| 'MODEL_INVALID_CONSTRAINT'
+	| 'MODEL_INVALID_INDEX'
 	| 'MODEL_NAME_COLLISION'
 	| 'ACL_INVALID_CONDITION'
 	| 'ACL_UNDEFINED_VARIABLE'

package/src/validation/index.ts

@@ -1,6 +1,6 @@
-export * from './AclValidator'
-export * from './ModelValidator'
-export * from './ValidationValidator'
-export * from './errors'
-export * from './SchemaValidator'
-export * from './MembershipResolver'
+export * from './AclValidator.js'
+export * from './ModelValidator.js'
+export * from './ValidationValidator.js'
+export * from './errors.js'
+export * from './SchemaValidator.js'
+export * from './MembershipResolver.js'

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { conditionSchema } from '../../../src/type-schema'
+import { conditionSchema } from '../../../src/type-schema/index.js'
 import { Model } from '@contember/schema'
 
 describe('condition schema', () => {

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { compareArraysIgnoreOrder } from '../../../src'
+import { compareArraysIgnoreOrder } from '../../../src/index.js'
 
 describe('deep compare', () => {
 	test('compare array ignore order - success', () => {