@contember/schema-utils 2.1.0-alpha.3 → 2.1.0-alpha.35

package/src/utils/printJsValue.ts

@@ -6,7 +6,6 @@ export class Literal {
 export type FormatterPath = ({ type: 'array' } | { type: 'object'; key: string })[]
 export type IndentDecider = (value: any, path: FormatterPath) => boolean
 
-
 export const printJsValue = (value: any, shouldIndentCb: IndentDecider = () => false, path: FormatterPath = []): string => {
 	if (value instanceof Literal) {
 		return value.value
@@ -18,7 +17,7 @@ export const printJsValue = (value: any, shouldIndentCb: IndentDecider = () => f
 		return value.toString(10) + 'n'
 	}
 	if (typeof value === 'string') {
-		return `'${value.replaceAll(/'/g, '\\\'')}'`
+		return `'${value.replaceAll(/'/g, "\\'")}'`
 	}
 	const shouldIndent = shouldIndentCb(value, path)
 	if (!shouldIndent) {
@@ -29,32 +28,31 @@ export const printJsValue = (value: any, shouldIndentCb: IndentDecider = () => f
 	const nl = '\n'
 
 	if (Array.isArray(value)) {
-		return  ''
-				+ '['
-				+ value.map((it, index, arr) =>
-					(shouldIndent ? nl + indent(1) : '')
-					+ printJsValue(it, shouldIndentCb, [...path, { type: 'array' }])
-					+ (shouldIndent ? ',' : ((index + 1) < arr.length ? ', ' : '')),
-				).join('')
-				+ (shouldIndent ? nl + indent(0) : '')
-				+ ']'
+		return ''
+			+ '['
+			+ value.map((it, index, arr) =>
+				(shouldIndent ? nl + indent(1) : '')
+				+ printJsValue(it, shouldIndentCb, [...path, { type: 'array' }])
+				+ (shouldIndent ? ',' : ((index + 1) < arr.length ? ', ' : ''))
+			).join('')
+			+ (shouldIndent ? nl + indent(0) : '')
+			+ ']'
 	}
 
 	return ''
-			+ '{'
-			+ (shouldIndent ? '' : ' ')
-			+ Object.entries(value).map(([key, value], index, arr) => {
-				const formattedKey = isSimpleIdentifier(key) ? key : `[${printJsValue(key)}]`
-				return ''
-					+ (shouldIndent ? nl + indent(1) : '')
-					+ formattedKey
-					+ ': '
-					+ printJsValue(value, shouldIndentCb, [...path, { type: 'object', key }])
-					+ (shouldIndent ? ',' : ((index + 1) < arr.length ? ', ' : ''))
-			}).join('')
-			+ (shouldIndent ? nl + indent(0) : ' ')
-			+ '}'
-
+		+ '{'
+		+ (shouldIndent ? '' : ' ')
+		+ Object.entries(value).map(([key, value], index, arr) => {
+			const formattedKey = isSimpleIdentifier(key) ? key : `[${printJsValue(key)}]`
+			return ''
+				+ (shouldIndent ? nl + indent(1) : '')
+				+ formattedKey
+				+ ': '
+				+ printJsValue(value, shouldIndentCb, [...path, { type: 'object', key }])
+				+ (shouldIndent ? ',' : ((index + 1) < arr.length ? ', ' : ''))
+		}).join('')
+		+ (shouldIndent ? nl + indent(0) : ' ')
+		+ '}'
 }
 
 const isSimpleIdentifier = (identifier: string): boolean => {

package/src/validation/AclValidator.ts

@@ -4,7 +4,6 @@ import { getEntity } from '../model'
 import { ErrorBuilder, ValidationError } from './errors'
 import { conditionSchema } from '../type-schema'
 
-
 export class AclValidator {
 	constructor(private readonly model: Model.Schema) {}
 
@@ -28,7 +27,6 @@ export class AclValidator {
 		roles: string[],
 		errorBuilder: ErrorBuilder,
 	): void {
-
 		this.validateInherits(permissions.inherits, roles, errorBuilder.for('inherits'))
 		this.validateVariables(permissions.variables, errorBuilder.for('variables'))
 		this.validatePermissions(permissions.entities, (permissions.variables as Acl.Variables) || {}, errorBuilder.for('entities'))

package/src/validation/ActionsValidator.ts

@@ -5,12 +5,13 @@ import { assertNever } from '../utils'
 import * as Typesafe from '@contember/typesafe'
 import { whereSchema } from '../type-schema/where'
 
-const manyArgsSchema = (args: {schema: Model.Schema; entity: Model.Entity}) => Typesafe.partial({
-	limit: Typesafe.integer,
-	offset: Typesafe.integer,
-	orderBy: Typesafe.array(Typesafe.anyJsonObject),
-	filter: whereSchema(args),
-})
+const manyArgsSchema = (args: { schema: Model.Schema; entity: Model.Entity }) =>
+	Typesafe.partial({
+		limit: Typesafe.integer,
+		offset: Typesafe.integer,
+		orderBy: Typesafe.array(Typesafe.anyJsonObject),
+		filter: whereSchema(args),
+	})
 
 export class ActionsValidator {
 	constructor(private readonly model: Model.Schema) {}
@@ -34,7 +35,6 @@ export class ActionsValidator {
 		}
 	}
 
-
 	private validateTrigger(trigger: Actions.AnyTrigger, errorBuilder: ErrorBuilder): void {
 		const entity = this.model.entities[trigger.entity]
 		if (!entity) {

package/src/validation/MembershipResolver.ts

@@ -3,7 +3,6 @@ import { getRoleVariables } from '../acl'
 import { conditionSchema } from '../type-schema'
 import { assertNever } from '../utils'
 
-
 export class MembershipResolver {
 	public static UnknownIdentity = { identityId: '00000000-0000-0000-0000-000000000000' }
 
@@ -14,6 +13,7 @@ export class MembershipResolver {
 			identityId: string
 			personId?: string
 		},
+		isAssumed: boolean,
 	): MembershipReadResult {
 		const errors: MembershipValidationError[] = []
 		const parsed: ParsedMembership[] = []
@@ -25,7 +25,7 @@ export class MembershipResolver {
 			}
 			const roleVariables = getRoleVariables(membership.role, acl)
 			for (const variable of membership.variables) {
-				if (!roleVariables[variable.name] || roleVariables[variable.name].type === Acl.VariableType.predefined) {
+				if (!roleVariables[variable.name] || (!isAssumed && roleVariables[variable.name].type === Acl.VariableType.predefined)) {
 					errors.push(
 						new MembershipValidationError(
 							membership.role,
@@ -35,7 +35,7 @@ export class MembershipResolver {
 					)
 				}
 			}
-			const [membershipErrors, parsedVariables] = this.readMembershipVariables(roleVariables, membership, identity)
+			const [membershipErrors, parsedVariables] = this.readMembershipVariables(roleVariables, membership, identity, isAssumed)
 			errors.push(...membershipErrors)
 			parsed.push({
 				role: membership.role,
@@ -48,19 +48,23 @@ export class MembershipResolver {
 	private readMembershipVariables(roleVariables: Acl.Variables, membership: Acl.Membership, identity: {
 		identityId: string
 		personId?: string
-	}): [MembershipValidationError[], ParsedMembershipVariable[]] {
+	}, isAssumed: boolean): [MembershipValidationError[], ParsedMembershipVariable[]] {
 		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':
-						parsedVariables.push({ name, condition: { in: [identity.identityId] } })
+						parsedVariables.push({
+							name,
+							condition: { in: isAssumed && inputVariable ? inputVariable.values : [identity.identityId] },
+						})
 						break
 					case 'personID':
 						parsedVariables.push({
 							name,
-							condition: { in: identity.personId ? [identity.personId] : [] },
+							condition: { in: isAssumed && inputVariable ? inputVariable.values : identity.personId ? [identity.personId] : [] },
 						})
 						break
 					default:
@@ -71,7 +75,6 @@ export class MembershipResolver {
 				continue
 			}
 
-			const inputVariable = membership.variables.find(it => it.name === name)
 			if (!inputVariable) {
 				if (variable.fallback) {
 					parsedVariables.push({ name, condition: variable.fallback })
@@ -84,7 +87,6 @@ export class MembershipResolver {
 
 			if (variable.type === Acl.VariableType.entity) {
 				parsedVariables.push({ name, condition: { in: inputVariable.values } }) // todo: cast to int where primary is int
-
 			} else if (variable.type === Acl.VariableType.condition) {
 				try {
 					const conditions = inputVariable.values.map(it => conditionSchema()(JSON.parse(it)))
@@ -128,7 +130,6 @@ export enum MembershipValidationErrorType {
 	VARIABLE_INVALID = 'variableInvalid',
 }
 
-
 export interface ParsedMembershipVariable {
 	readonly name: string
 	readonly condition: Input.Condition

package/src/validation/ModelValidator.ts

@@ -5,9 +5,8 @@ import { acceptEveryFieldVisitor, getTargetEntity, isColumn, isInverseRelation,
 const IDENTIFIER_PATTERN = /^[_a-zA-Z][_a-zA-Z0-9]*$/
 const RESERVED_WORDS = ['and', 'or', 'not']
 
-
 export class ModelValidator {
-	constructor(private readonly model: Model.Schema) { }
+	constructor(private readonly model: Model.Schema) {}
 
 	public validate(): ValidationError[] {
 		const errorBuilder = new ErrorBuilder([], [])
@@ -121,7 +120,7 @@ export class ModelValidator {
 			return errors.add('MODEL_UNDEFINED_ENTITY', `Target entity ${targetEntityName} not found`)
 		}
 		if (((it: Model.AnyRelation): it is Model.AnyRelation & Model.OrderableRelation => 'orderBy' in it)(field)) {
-			(field as Model.OrderableRelation).orderBy?.forEach(it => {
+			;(field as Model.OrderableRelation).orderBy?.forEach(it => {
 				let entity = targetEntity
 
 				for (let i = 0; i < it.path.length; i++) {
@@ -147,15 +146,15 @@ export class ModelValidator {
 				return errors.add('MODEL_INVALID_VIEW_USAGE', 'Many-has-many relation is not allowed on a view entity.')
 			}
 			if (
-				!targetEntity.view &&
-				field.type === Model.RelationType.OneHasMany
+				!targetEntity.view
+				&& field.type === Model.RelationType.OneHasMany
 			) {
 				return errors.add('MODEL_INVALID_VIEW_USAGE', 'One-has-many relation fields on views must point to a view entity.')
 			}
 			if (
-				!targetEntity.view &&
-				field.type === Model.RelationType.OneHasOne &&
-				!('joiningColumn' in field)
+				!targetEntity.view
+				&& field.type === Model.RelationType.OneHasOne
+				&& !('joiningColumn' in field)
 			) {
 				return errors.add('MODEL_INVALID_VIEW_USAGE', 'One-has-one relation fields on views must be owning or point to a view entity.')
 			}
@@ -172,7 +171,10 @@ export class ModelValidator {
 				return errors.add('MODEL_RELATION_REQUIRED', `${relationDescription} not a relation`)
 			}
 			if (targetField.target !== entityName) {
-				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference to entity ${entityName} expected, but ${targetField.target} given`)
+				return errors.add(
+					'MODEL_INVALID_RELATION_DEFINITION',
+					`${relationDescription} back reference to entity ${entityName} expected, but ${targetField.target} given`,
+				)
 			}
 			if (!isOwningRelation(targetField)) {
 				errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} not an owning relation`)
@@ -182,7 +184,10 @@ export class ModelValidator {
 				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} inverse relation is not set`)
 			}
 			if (targetField.inversedBy !== field.name) {
-				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.inversedBy} given`)
+				return errors.add(
+					'MODEL_INVALID_RELATION_DEFINITION',
+					`${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.inversedBy} given`,
+				)
 			}
 			if (field.type === Model.RelationType.OneHasOne && targetField.type !== Model.RelationType.OneHasOne) {
 				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} "OneHasOne" type expected, "${targetField.type}" given`)
@@ -205,7 +210,10 @@ export class ModelValidator {
 					return errors.add('MODEL_RELATION_REQUIRED', `${relationDescription} not a relation`)
 				}
 				if (targetField.target !== entityName) {
-					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference to entity ${entityName} expected, but ${targetField.target} given`)
+					return errors.add(
+						'MODEL_INVALID_RELATION_DEFINITION',
+						`${relationDescription} back reference to entity ${entityName} expected, but ${targetField.target} given`,
+					)
 				}
 				if (!isInverseRelation(targetField)) {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} not an inverse relation`)
@@ -214,7 +222,10 @@ export class ModelValidator {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} owning relation is not set`)
 				}
 				if (targetField.ownedBy !== field.name) {
-					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.ownedBy} given`)
+					return errors.add(
+						'MODEL_INVALID_RELATION_DEFINITION',
+						`${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.ownedBy} given`,
+					)
 				}
 				if (field.type === Model.RelationType.OneHasOne && targetField.type !== Model.RelationType.OneHasOne) {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} "OneHasOne" type expected, "${targetField.type}" given`)
@@ -244,7 +255,6 @@ export class ModelValidator {
 		}
 	}
 
-
 	private validateMetaSuffixCollisions(entities: Model.Entity[], errorBuilder: ErrorBuilder) {
 		const entityNames = new Set(entities.map(it => it.name))
 		for (const entity of entities) {
@@ -252,13 +262,15 @@ export class ModelValidator {
 				const baseName = entity.name.substring(0, entity.name.length - 4)
 				if (entityNames.has(baseName)) {
 					errorBuilder.for(entity.name)
-						.add('MODEL_NAME_COLLISION', `entity ${entity.name} collides with entity ${baseName}, because a GraphQL type with "Meta" suffix is created for every entity`)
+						.add(
+							'MODEL_NAME_COLLISION',
+							`entity ${entity.name} collides with entity ${baseName}, because a GraphQL type with "Meta" suffix is created for every entity`,
+						)
 				}
 			}
 		}
 	}
 
-
 	private validateTableNameCollisions(entities: Model.Entity[], errorBuilder: ErrorBuilder) {
 		const relationNames: Record<string, string> = {}
 		for (const entity of entities) {
@@ -280,25 +292,25 @@ export class ModelValidator {
 					if (relationNames[joiningTable.tableName]) {
 						entityErrorBuilder
 							.for(relation.name)
-							.add('MODEL_NAME_COLLISION',
-								`${description} collides with a ${relationNames[joiningTable.tableName]}.` +
-								'Consider using plural for a relation name or change the joining table name using .joiningTable(...) in schema definition.',
+							.add(
+								'MODEL_NAME_COLLISION',
+								`${description} collides with a ${relationNames[joiningTable.tableName]}.`
+									+ 'Consider using plural for a relation name or change the joining table name using .joiningTable(...) in schema definition.',
 							)
 					} else {
 						relationNames[joiningTable.tableName] = description
 					}
 				},
 				visitColumn: () => {},
-				visitManyHasManyInverse: () => { },
-				visitOneHasMany: () => { },
-				visitOneHasOneInverse: () => { },
-				visitOneHasOneOwning: () => { },
-				visitManyHasOne: () => { },
+				visitManyHasManyInverse: () => {},
+				visitOneHasMany: () => {},
+				visitOneHasOneInverse: () => {},
+				visitOneHasOneOwning: () => {},
+				visitManyHasOne: () => {},
 			})
 		}
 	}
 
-
 	private validateAliasedTypesCollision(entities: Model.Entity[], errorBuilder: ErrorBuilder) {
 		const aliasedTypes = new Map<string, Model.ColumnType>()
 		for (const entity of entities) {
@@ -314,16 +326,15 @@ export class ModelValidator {
 					}
 					aliasedTypes.set(column.typeAlias, column.type)
 				},
-				visitManyHasManyOwning: () => { },
-				visitManyHasManyInverse: () => { },
-				visitOneHasMany: () => { },
-				visitOneHasOneInverse: () => { },
-				visitOneHasOneOwning: () => { },
-				visitManyHasOne: () => { },
+				visitManyHasManyOwning: () => {},
+				visitManyHasManyInverse: () => {},
+				visitOneHasMany: () => {},
+				visitOneHasOneInverse: () => {},
+				visitOneHasOneOwning: () => {},
+				visitManyHasOne: () => {},
 			})
 		}
 	}
 }
 
-const isRelation = (field: Model.AnyField): field is Model.AnyRelation =>
-	Object.values(Model.RelationType).includes(field.type as Model.RelationType)
+const isRelation = (field: Model.AnyField): field is Model.AnyRelation => Object.values(Model.RelationType).includes(field.type as Model.RelationType)

package/src/validation/SchemaValidator.ts

@@ -19,22 +19,23 @@ export class SchemaValidator {
 		const aclValidator = new AclValidator(schema.model)
 		const aclErrors = aclValidator.validate(schema.acl)
 
-
 		const validationValidator = new ValidationValidator(schema.model)
 		const validationErrors = validationValidator.validate(schema.validation)
 
 		const actionsValidator = new ActionsValidator(schema.model)
-		const actionsErrors  = actionsValidator.validate(schema.actions)
+		const actionsErrors = actionsValidator.validate(schema.actions)
 
 		const allErrors = [...aclErrors, ...modelErrors, ...validationErrors, ...actionsErrors]
 		if (skippedErrors.length === 0) {
 			return allErrors
 		}
 		return allErrors.filter(
-			err => !skippedErrors.some(
-				rule => err.code === rule.code
-					&& (!rule.path || err.path.join('.') === rule.path),
-			),
+			err =>
+				!skippedErrors.some(
+					rule =>
+						err.code === rule.code
+						&& (!rule.path || err.path.join('.') === rule.path),
+				),
 		)
 	}
 }

package/src/validation/ValidationValidator.ts

@@ -65,7 +65,6 @@ export class ValidationValidator {
 		this.validateValidator(errorBuilder.for('validator'), rule.validator, entity, field)
 	}
 
-
 	private validateValidator(
 		errorBuilder: ErrorBuilder,
 		validator: Validation.Validator,
@@ -120,7 +119,7 @@ export class ValidationValidator {
 				)
 				return
 			default:
-				((_: never) => {
+				;((_: never) => {
 					errorBuilder.for('operation', `Operation ${(validatorCast as any).operation} is not an valid option`)
 				})(validatorCast)
 		}
@@ -135,7 +134,6 @@ export class ValidationValidator {
 		this.validateValidator(errorBuilder.for('validator'), argument.validator, entity, field)
 	}
 
-
 	private validatePathArgument(
 		errorBuilder: ErrorBuilder,
 		argument: Validation.PathArgument,

package/src/validation/errors.ts

@@ -11,21 +11,18 @@ export type ValidationErrorCode =
 	| 'MODEL_INVALID_ENTITY_NAME'
 	| 'MODEL_INVALID_CONSTRAINT'
 	| 'MODEL_NAME_COLLISION'
-
 	| 'ACL_INVALID_CONDITION'
 	| 'ACL_UNDEFINED_VARIABLE'
 	| 'ACL_UNDEFINED_FIELD'
 	| 'ACL_UNDEFINED_PREDICATE'
 	| 'ACL_UNDEFINED_ROLE'
 	| 'ACL_UNDEFINED_ENTITY'
-
 	| 'ACTIONS_NAME_MISMATCH'
 	| 'ACTIONS_INVALID_CONDITION'
 	| 'ACTIONS_UNDEFINED_FIELD'
 	| 'ACTIONS_UNDEFINED_ENTITY'
 	| 'ACTIONS_UNDEFINED_TRIGGER_TARGET'
 	| 'ACTIONS_INVALID_SELECTION'
-
 	| 'VALIDATION_UNDEFINED_ENTITY'
 	| 'VALIDATION_UNDEFINED_FIELD'
 	| 'VALIDATION_NOT_IMPLEMENTED'

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

@@ -1,4 +1,4 @@
-import { expect, test, describe } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 import { conditionSchema } from '../../../src/type-schema'
 import { Model } from '@contember/schema'
 
@@ -31,7 +31,6 @@ describe('condition schema', () => {
 		expect(() => conditionSchema(Model.ColumnType.Int)(condition)).toThrow('value at root: extra property containsCI found')
 	})
 
-
 	test('accept non-json condition for unknown type', () => {
 		const condition = {
 			eq: 'foo',

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

@@ -1,4 +1,4 @@
-import { expect, describe, test } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 import { compareArraysIgnoreOrder } from '../../../src'
 
 describe('deep compare', () => {
@@ -38,7 +38,6 @@ describe('deep compare', () => {
 		expect(actual).toStrictEqual([{
 			path: [],
 			message: 'Array item: {"foo":"bar"} not found in [{"lorem":"ipsum"},{"lorem":"ipsum"}]',
-		}],
-		)
+		}])
 	})
 })

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

@@ -18,7 +18,6 @@ test('lax schema converter basic', () => {
 	expect(converter.convert()).toMatchSnapshot()
 })
 
-
 test('lax schema converter one-has-many', () => {
 	const converter = new LaxSchemaConverter(
 		{
@@ -57,7 +56,6 @@ test('lax schema converter one-has-many', () => {
 	expect(converter2.convert()).toStrictEqual(schema1)
 })
 
-
 test('lax schema converter many-has-many', () => {
 	const converter = new LaxSchemaConverter(
 		{
@@ -96,7 +94,6 @@ test('lax schema converter many-has-many', () => {
 	expect(converter2.convert()).toStrictEqual(schema1)
 })
 
-
 test('lax schema converter one-has-one', () => {
 	const converter = new LaxSchemaConverter(
 		{
@@ -134,4 +131,3 @@ test('lax schema converter one-has-one', () => {
 	)
 	expect(converter2.convert()).toStrictEqual(schema1)
 })
-