@contember/schema-utils 1.2.0-alpha.8 → 1.2.0-beta.1

package/src/model/modelUtils.ts

@@ -28,10 +28,18 @@ export const getEntity = (schema: Model.Schema, entityName: string): Model.Entit
 	return entity
 }
 
+export const getField = (entity: Model.Entity, fieldName: string): Model.AnyField => {
+	const field = entity.fields[fieldName]
+	if (!field) {
+		throw createFieldNotFoundError(entity.name, fieldName)
+	}
+	return field
+}
+
 export const getColumnName = (schema: Model.Schema, entity: Model.Entity, fieldName: string) => {
 	return acceptFieldVisitor(schema, entity, fieldName, {
-		visitColumn: (entity, column) => column.columnName,
-		visitRelation: (entity, relation) => {
+		visitColumn: ({ column }) => column.columnName,
+		visitRelation: ({ entity, relation }) => {
 			if (isIt<Model.JoiningColumnRelation>(relation, 'joiningColumn')) {
 				return relation.joiningColumn.columnName
 			}
@@ -57,8 +65,8 @@ export const tryGetColumnName = (schema: Model.Schema, entity: Model.Entity, fie
 export const getColumnType = (schema: Model.Schema, entity: Model.Entity, fieldName: string): string => {
 	return acceptFieldVisitor(schema, entity, fieldName, {
 		// TODO solve enum handling properly maybe we should distinguish between domain and column type
-		visitColumn: (entity, column) => (column.type === Model.ColumnType.Enum ? 'text' : column.columnType),
-		visitRelation: (entity, relation, targetEntity) => {
+		visitColumn: ({ column }) => (column.type === Model.ColumnType.Enum ? 'text' : column.columnType),
+		visitRelation: ({ entity, relation, targetEntity }) => {
 			if (isIt<Model.JoiningColumnRelation>(relation, 'joiningColumn')) {
 				return getColumnType(schema, targetEntity, targetEntity.primary)
 			}
@@ -77,7 +85,7 @@ export const getTargetEntity = (
 ): Model.Entity | null => {
 	return acceptFieldVisitor(schema, entity, relationName, {
 		visitColumn: () => null,
-		visitRelation: (entity, relation, targetEntity) => targetEntity,
+		visitRelation: ({ targetEntity }) => targetEntity,
 	})
 }
 
@@ -87,9 +95,7 @@ export const acceptEveryFieldVisitor = <T>(
 	visitor: Model.FieldVisitor<T>,
 ): { [fieldName: string]: T } => {
 	const entityObj: Model.Entity = typeof entity === 'string' ? getEntity(schema, entity) : entity
-	if (!entityObj) {
-		throw createEntityNotFoundError(typeof entity === 'string' ? entity : 'unknown')
-	}
+
 	const result: { [fieldName: string]: T } = {}
 	for (const field in entityObj.fields) {
 		result[field] = acceptFieldVisitor(schema, entityObj, field, visitor)
@@ -104,34 +110,28 @@ export const acceptFieldVisitor = <T>(
 	visitor: Model.FieldVisitor<T>,
 ): T => {
 	const entityObj: Model.Entity = typeof entity === 'string' ? getEntity(schema, entity) : entity
-	if (!entityObj) {
-		throw createEntityNotFoundError(typeof entity === 'string' ? entity : 'unknown')
-	}
+
 	const fieldObj: Model.AnyField = typeof field === 'string' ? entityObj.fields[field] : field
 	if (!fieldObj) {
 		throw createFieldNotFoundError(entityObj.name, typeof field === 'string' ? field : 'unknown')
 	}
+
 	if (isIt<Model.AnyColumn>(fieldObj, 'columnType')) {
-		return visitor.visitColumn(entityObj, fieldObj)
-	}
-	if (!isIt<Model.AnyRelation>(fieldObj, 'target')) {
-		throw new Error(`Invalid field type`)
+		return visitor.visitColumn({
+			entity: entityObj,
+			column: fieldObj,
+		})
 	}
-	const targetEntity = getEntity(schema, fieldObj.target)
 
 	if (isIt<Model.ColumnVisitor<T> & Model.RelationVisitor<T>>(visitor, 'visitRelation')) {
-		let targetRelation = null
-		if (isOwningRelation(fieldObj)) {
-			targetRelation = fieldObj.inversedBy ? targetEntity.fields[fieldObj.inversedBy] || null : null
-		} else if (isInverseRelation(fieldObj)) {
-			targetRelation = targetEntity.fields[fieldObj.ownedBy]
-		} else {
-			throw new Error('Invalid relaton type')
-		}
-		if (targetRelation && !isIt<Model.Relation>(targetRelation, 'target')) {
-			throw new Error('Invalid target')
-		}
-		return visitor.visitRelation(entityObj, fieldObj, targetEntity, targetRelation)
+		return acceptRelationTypeVisitor(schema, entityObj, fieldObj, {
+			visitManyHasManyInverse: visitor.visitRelation.bind(visitor),
+			visitManyHasManyOwning: visitor.visitRelation.bind(visitor),
+			visitOneHasMany: visitor.visitRelation.bind(visitor),
+			visitOneHasOneInverse: visitor.visitRelation.bind(visitor),
+			visitOneHasOneOwning: visitor.visitRelation.bind(visitor),
+			visitManyHasOne: visitor.visitRelation.bind(visitor),
+		})
 	}
 
 	if (isIt<Model.ColumnVisitor<T> & Model.RelationByGenericTypeVisitor<T>>(visitor, 'visitHasMany')) {
@@ -148,7 +148,8 @@ export const acceptFieldVisitor = <T>(
 	if (isIt<Model.ColumnVisitor<T> & Model.RelationByTypeVisitor<T>>(visitor, 'visitManyHasManyInverse')) {
 		return acceptRelationTypeVisitor(schema, entityObj, fieldObj, visitor)
 	}
-	throw new Error('Invalid field type')
+
+	throw new Error()
 }
 
 export const acceptRelationTypeVisitor = <T>(
@@ -157,49 +158,50 @@ export const acceptRelationTypeVisitor = <T>(
 	relation: string | Model.AnyRelation,
 	visitor: Model.RelationByTypeVisitor<T>,
 ): T => {
-	const entityObj: Model.Entity = typeof entity === 'string' ? getEntity(schema, entity) : entity
-	if (!entityObj) {
-		throw createEntityNotFoundError(typeof entity === 'string' ? entity : 'unknown')
-	}
+	const entityObj = typeof entity === 'string' ? getEntity(schema, entity) : entity
+
 	const relationObj: Model.AnyField = typeof relation === 'string' ? entityObj.fields[relation] : relation
 	if (!relationObj) {
 		throw createFieldNotFoundError(entityObj.name, typeof relation === 'string' ? relation : 'unknown')
 	}
+
 	if (!isRelation(relationObj)) {
 		throw new ModelError(
 			ModelErrorCode.NOT_RELATION,
 			`Field ${relationObj.name} of entity ${entityObj.name} is not a relation`,
 		)
 	}
+
 	const targetEntity = getEntity(schema, relationObj.target)
 
 	if (isInverseRelation(relationObj)) {
 		const targetRelation = targetEntity.fields[relationObj.ownedBy]
-		if (!isRelation(targetRelation)) {
-			throw new Error('Invalid target relation')
-		}
 		switch (relationObj.type) {
 			case Model.RelationType.ManyHasMany:
-				return visitor.visitManyHasManyInverse(
-					entityObj,
-					relationObj,
-					targetEntity,
-					targetRelation as Model.ManyHasManyOwningRelation,
+				return visitor.visitManyHasManyInverse({
+					type: 'manyHasManyInverse',
+					entity: entityObj,
+					relation: relationObj,
+					targetEntity: targetEntity,
+					targetRelation: targetRelation as Model.ManyHasManyOwningRelation,
+				},
 				)
 			case Model.RelationType.OneHasOne:
-				return visitor.visitOneHasOneInverse(
-					entityObj,
-					relationObj,
-					targetEntity,
-					targetRelation as Model.OneHasOneOwningRelation,
-				)
+				return visitor.visitOneHasOneInverse({
+					type: 'oneHasOneInverse',
+					entity: entityObj,
+					relation: relationObj,
+					targetEntity: targetEntity,
+					targetRelation: targetRelation as Model.OneHasOneOwningRelation,
+				})
 			case Model.RelationType.OneHasMany:
-				return visitor.visitOneHasMany(
-					entityObj, //
-					relationObj,
-					targetEntity,
-					targetRelation as Model.ManyHasOneRelation,
-				)
+				return visitor.visitOneHasMany({
+					type: 'oneHasMany',
+					entity: entityObj,
+					relation: relationObj,
+					targetEntity: targetEntity,
+					targetRelation: targetRelation as Model.ManyHasOneRelation,
+				})
 			default:
 				return assertNever(relationObj)
 		}
@@ -208,26 +210,29 @@ export const acceptRelationTypeVisitor = <T>(
 
 		switch (relationObj.type) {
 			case Model.RelationType.ManyHasMany:
-				return visitor.visitManyHasManyOwning(
-					entityObj,
-					relationObj,
-					targetEntity,
-					targetRelation as Model.ManyHasManyInverseRelation,
-				)
+				return visitor.visitManyHasManyOwning({
+					type: 'manyHasManyOwning',
+					entity: entityObj,
+					relation: relationObj,
+					targetEntity: targetEntity,
+					targetRelation: targetRelation as Model.ManyHasManyInverseRelation,
+				})
 			case Model.RelationType.OneHasOne:
-				return visitor.visitOneHasOneOwning(
-					entityObj,
-					relationObj,
-					targetEntity,
-					targetRelation as Model.OneHasOneInverseRelation,
-				)
+				return visitor.visitOneHasOneOwning({
+					type: 'oneHasOneOwning',
+					entity: entityObj,
+					relation: relationObj,
+					targetEntity: targetEntity,
+					targetRelation: targetRelation as Model.OneHasOneInverseRelation,
+				})
 			case Model.RelationType.ManyHasOne:
-				return visitor.visitManyHasOne(
-					entityObj, //
-					relationObj,
-					targetEntity,
-					targetRelation as Model.OneHasManyRelation,
-				)
+				return visitor.visitManyHasOne({
+					type: 'manyHasOne',
+					entity: entityObj, //
+					relation: relationObj,
+					targetEntity: targetEntity,
+					targetRelation: targetRelation as Model.OneHasManyRelation,
+				})
 			default:
 				return assertNever(relationObj)
 		}

package/src/schemaNormalizer.ts

@@ -26,6 +26,7 @@ export const normalizeSchema = <S extends Schema>(schema: S): S => {
 						export: true,
 						import: true,
 					},
+					debug: true,
 					...((schema.acl.roles?.[ProjectRole.ADMIN] as Acl.RolePermissions | undefined) || {}),
 				},
 				[ProjectRole.CONTENT_ADMIN]: {

package/src/type-schema/acl.ts

@@ -1,5 +1,6 @@
 import { Acl, Model } from '@contember/schema'
 import * as Typesafe from '@contember/typesafe'
+import { conditionSchema } from './condition'
 
 const membershipMatchRuleSchema = Typesafe.record(
 	Typesafe.string,
@@ -40,20 +41,37 @@ const contentPermissionsSchema = Typesafe.partial({
 })
 const contentSchemaCheck: Typesafe.Equals<Acl.ContentPermissions, ReturnType<typeof contentPermissionsSchema>> = true
 
+const entityVariableSchema = Typesafe.intersection(
+	Typesafe.object({
+		type: Typesafe.literal(Acl.VariableType.entity),
+		entityName: Typesafe.string,
+	}),
+	Typesafe.partial({
+		fallback: conditionSchema(),
+	}),
+)
+const entityVariableSchemaCheck: Typesafe.Equals<Acl.EntityVariable, ReturnType<typeof entityVariableSchema>> = true
+
+const predefinedVariableSchema = Typesafe.object({
+	type: Typesafe.literal(Acl.VariableType.predefined),
+	value: Typesafe.enumeration('identityID', 'personID'),
+})
+const conditionVariableSchema = Typesafe.intersection(
+	Typesafe.object({
+		type: Typesafe.literal(Acl.VariableType.condition),
+	}),
+	Typesafe.partial({
+		fallback: conditionSchema(),
+	}),
+)
+const conditionVariableSchemaCheck: Typesafe.Equals<Acl.ConditionVariable, ReturnType<typeof conditionVariableSchema>> = true
+
 const variablesSchema = Typesafe.record(
 	Typesafe.string,
 	Typesafe.union(
-		Typesafe.object({
-			type: Typesafe.literal(Acl.VariableType.entity),
-			entityName: Typesafe.string,
-		}),
-		Typesafe.object({
-			type: Typesafe.literal(Acl.VariableType.predefined),
-			value: Typesafe.enumeration('identityID', 'personID'),
-		}),
-		Typesafe.object({
-			type: Typesafe.literal(Acl.VariableType.condition),
-		}),
+		entityVariableSchema as Typesafe.Type<Acl.EntityVariable>,
+		predefinedVariableSchema,
+		conditionVariableSchema as Typesafe.Type<Acl.ConditionVariable>,
 	),
 )
 
@@ -102,6 +120,7 @@ const baseRolePermissionsSchema = Typesafe.intersection(
 		tenant: tenantPermissionsSchema,
 		system: systemPermissionsSchema,
 		content: contentPermissionsSchema,
+		debug: Typesafe.boolean,
 	}),
 )
 const baseRolePermissionsCheck: Typesafe.Equals<Acl.BaseRolePermissions, ReturnType<typeof baseRolePermissionsSchema>> = true

package/src/type-schema/condition.ts

@@ -1,5 +1,5 @@
 import * as Typesafe from '@contember/typesafe'
-import { Type } from '@contember/typesafe'
+import { Json, Type } from '@contember/typesafe'
 import { Input, Model, Value } from '@contember/schema'
 
 export const conditionSchema = <T extends Value.FieldValue>(type?: Model.ColumnType): Type<Input.Condition<T>> => {
@@ -7,13 +7,13 @@ export const conditionSchema = <T extends Value.FieldValue>(type?: Model.ColumnT
 	return conditionSchemaInner(metadata)
 }
 
-interface ResolvedColumnMetadata<T> {
+interface ResolvedColumnMetadata<T extends Json> {
 	type: Typesafe.Type<T>
 	isJson?: boolean
 	isString?: boolean
 }
 
-const conditionSchemaInner = <T>(metadata: ResolvedColumnMetadata<T>): Type<Input.Condition<T>> => {
+const conditionSchemaInner = <T extends Json>(metadata: ResolvedColumnMetadata<T>): Type<Input.Condition<T>> => {
 	return (input: unknown, path: PropertyKey[] = []): Input.Condition<T> => {
 		const self = conditionSchemaInner(metadata)
 		const inner = metadata.type

package/src/type-schema/index.ts

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

package/src/type-schema/settings.ts

@@ -0,0 +1,8 @@
+import * as Typesafe from '@contember/typesafe'
+import { Settings } from '@contember/schema'
+
+export const settingsSchema = Typesafe.partial({
+	useExistsInHasManyFilter: Typesafe.boolean,
+})
+
+const settingSchemaCheck: Typesafe.Equals<Settings.Schema, ReturnType<typeof settingsSchema>> = true

package/src/validation/AclValidator.ts

@@ -2,8 +2,7 @@ import { Acl, Model } from '@contember/schema'
 import { PredicateDefinitionProcessor } from '../acl'
 import { getEntity } from '../model'
 import { ErrorBuilder, ValidationError } from './errors'
-import { conditionSchema } from '../type-schema/condition'
-import { anyJson } from '@contember/typesafe'
+import { conditionSchema } from '../type-schema'
 
 
 export class AclValidator {
@@ -42,7 +41,7 @@ export class AclValidator {
 		}
 		for (const inheritsFrom of inherits) {
 			if (!roles.includes(inheritsFrom)) {
-				errorBuilder.for(inheritsFrom).add('Referenced role not exists.')
+				errorBuilder.for(inheritsFrom).add('ACL_UNDEFINED_ROLE', 'Referenced role not exists.')
 			}
 		}
 	}
@@ -60,7 +59,7 @@ export class AclValidator {
 		switch (variable.type) {
 			case 'entity':
 				if (!this.model.entities[variable.entityName]) {
-					errorBuilder.add(`Entity "${variable.entityName}" not found`)
+					errorBuilder.add('ACL_UNDEFINED_ENTITY', `Entity "${variable.entityName}" not found`)
 					return
 				}
 		}
@@ -73,7 +72,7 @@ export class AclValidator {
 				continue
 			}
 			if (!this.model.entities[entityName]) {
-				errorBuilder.add(`Entity ${entityName} not found`)
+				errorBuilder.add('ACL_UNDEFINED_ENTITY', `Entity ${entityName} not found`)
 				continue
 			}
 			const entity = getEntity(this.model, entityName)
@@ -132,25 +131,25 @@ export class AclValidator {
 			handleColumn: ctx => {
 				if (typeof ctx.value === 'string') {
 					if (!variables[ctx.value]) {
-						errorBuilder.for(...ctx.path).add(`Undefined variable ${ctx.value}`)
+						errorBuilder.for(...ctx.path).add('ACL_UNDEFINED_VARIABLE', `Undefined variable ${ctx.value}`)
 					}
 				} else {
 					try {
 						conditionSchema(ctx.column.type)(ctx.value)
 					} catch (e: any) {
-						errorBuilder.for(...ctx.path).add(`Invalid condition (${e.message}): ${JSON.stringify(ctx.value)}`)
+						errorBuilder.for(...ctx.path).add('ACL_INVALID_CONDITION', `Invalid condition (${e.message}): ${JSON.stringify(ctx.value)}`)
 					}
 				}
 				return ctx.value
 			},
 			handleRelation: ctx => {
 				if (typeof ctx.value === 'string' && !variables[ctx.value]) {
-					errorBuilder.for(...ctx.path).add(`Undefined variable ${ctx.value}`)
+					errorBuilder.for(...ctx.path).add('ACL_UNDEFINED_VARIABLE', `Undefined variable ${ctx.value}`)
 				}
 				return ctx.value
 			},
 			handleUndefinedField: ctx => {
-				errorBuilder.for(...ctx.path).add(`Undefined field ${ctx.name} on entity ${ctx.entity.name}`)
+				errorBuilder.for(...ctx.path).add('ACL_UNDEFINED_FIELD', `Undefined field ${ctx.name} on entity ${ctx.entity.name}`)
 				return ctx.value
 			},
 		})
@@ -184,7 +183,7 @@ export class AclValidator {
 				continue
 			}
 			if (!entity.fields[field]) {
-				errorBuilder.add(`Field ${field} not found on entity ${entity.name}`)
+				errorBuilder.add('ACL_UNDEFINED_FIELD', `Field ${field} not found on entity ${entity.name}`)
 			}
 			this.validatePredicate(permissions[field], predicates, errorBuilder.for(field))
 		}
@@ -199,7 +198,7 @@ export class AclValidator {
 			return
 		}
 		if (!predicates[predicate]) {
-			errorBuilder.add(`Predicate ${predicate} not found`)
+			errorBuilder.add('ACL_UNDEFINED_PREDICATE', `Predicate ${predicate} not found`)
 		}
 	}
 }

package/src/validation/MembershipResolver.ts

@@ -1,6 +1,7 @@
 import { Acl, Input } from '@contember/schema'
 import { getRoleVariables } from '../acl'
 import { conditionSchema } from '../type-schema'
+import { assertNever } from '../utils'
 
 
 export class MembershipResolver {
@@ -51,7 +52,6 @@ export class MembershipResolver {
 		const errors: MembershipValidationError[] = []
 		const parsedVariables: ParsedMembershipVariable[] = []
 		for (const [name, variable] of Object.entries(roleVariables)) {
-			const inputVariable = membership.variables.find(it => it.name === name)
 			if (variable.type === Acl.VariableType.predefined) {
 				switch (variable.value) {
 					case 'identityID':
@@ -71,9 +71,14 @@ export class MembershipResolver {
 				continue
 			}
 
+			const inputVariable = membership.variables.find(it => it.name === name)
 			if (!inputVariable) {
-				errors.push(new MembershipValidationError(membership.role, MembershipValidationErrorType.VARIABLE_EMPTY, name))
-				parsedVariables.push({ name, condition: { never: true } })
+				if (variable.fallback) {
+					parsedVariables.push({ name, condition: variable.fallback })
+				} else {
+					errors.push(new MembershipValidationError(membership.role, MembershipValidationErrorType.VARIABLE_EMPTY, name))
+					parsedVariables.push({ name, condition: { never: true } })
+				}
 				continue
 			}
 
@@ -91,6 +96,8 @@ export class MembershipResolver {
 					errors.push(new MembershipValidationError(membership.role, MembershipValidationErrorType.VARIABLE_INVALID, name))
 					parsedVariables.push({ name, condition: { never: true } })
 				}
+			} else {
+				assertNever(variable)
 			}
 		}
 		return [errors, parsedVariables]