@contember/schema-utils 1.1.2 → 1.2.0-alpha.11

package/src/validation/ModelValidator.ts

@@ -105,12 +105,21 @@ export class ModelValidator {
 			})
 		}
 		if (partialEntity.view) {
+			if (field.type === Model.RelationType.ManyHasMany) {
+				return errors.add('Many-has-many relation is not allowed on a view entity.')
+			}
+			if (
+				!targetEntity.view &&
+				field.type === Model.RelationType.OneHasMany
+			) {
+				return errors.add('One-has-many relation fields on views must point to a view entity.')
+			}
 			if (
-				field.type === Model.RelationType.ManyHasMany ||
-				field.type === Model.RelationType.OneHasMany ||
-				(field.type === Model.RelationType.OneHasOne && !('joiningColumn' in field))
+				!targetEntity.view &&
+				field.type === Model.RelationType.OneHasOne &&
+				!('joiningColumn' in field)
 			) {
-				return errors.add('This relation type is not allowed on a view entity. Only one-has-one owning and many-has one are allowed.')
+				return errors.add('One-has-one relation fields on views must be owning or point to a view entity.')
 			}
 		}
 		if (isInverseRelation(field)) {
@@ -212,7 +221,7 @@ export class ModelValidator {
 		for (const entity of entities) {
 			const entityErrorBuilder = errorBuilder.for(entity.name)
 			acceptEveryFieldVisitor(this.model, entity, {
-				visitManyHasManyOwning: (entity, relation) => {
+				visitManyHasManyOwning: ({ entity, relation }) => {
 					const joiningTable = relation.joiningTable
 					const description = `relation ${entity.name}::${relation.name}`
 					if (tableNames[joiningTable.tableName]) {
@@ -226,7 +235,7 @@ export class ModelValidator {
 						tableNames[joiningTable.tableName] = description
 					}
 				},
-				visitColumn: (entity, column) => {
+				visitColumn: ({ entity, column }) => {
 					if (!column.typeAlias) {
 						return
 					}

package/src/validation/index.ts

@@ -3,3 +3,4 @@ export * from './ModelValidator'
 export * from './ValidationValidator'
 export * from './errors'
 export * from './SchemaValidator'
+export * from './MembershipResolver'

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

@@ -0,0 +1,55 @@
+import { assert, test, describe } from 'vitest'
+import { conditionSchema } from '../../../src/type-schema'
+import { Model } from '@contember/schema'
+
+describe('condition schema', () => {
+	test('accept composite type', () => {
+		const condition = {
+			and: [{ isNull: true }, { not: { isNull: false } }],
+		}
+		assert.deepStrictEqual(conditionSchema()(condition), condition)
+	})
+
+	test('accept string-only condition for unknown type', () => {
+		const condition = {
+			containsCI: 'foo',
+		}
+		assert.deepStrictEqual(conditionSchema()(condition), condition)
+	})
+
+	test('accept string-only condition for string type', () => {
+		const condition = {
+			containsCI: 'foo',
+		}
+		assert.deepStrictEqual(conditionSchema(Model.ColumnType.String)(condition), condition)
+	})
+
+	test('reject string-only condition for int type', () => {
+		const condition = {
+			containsCI: 'foo',
+		}
+		assert.throw(() => conditionSchema(Model.ColumnType.Int)(condition), 'value at root: extra property containsCI found')
+	})
+
+
+	test('accept non-json condition for unknown type', () => {
+		const condition = {
+			eq: 'foo',
+		}
+		assert.deepStrictEqual(conditionSchema()(condition), condition)
+	})
+
+	test('accept non-json condition for string type', () => {
+		const condition = {
+			eq: 'foo',
+		}
+		assert.deepStrictEqual(conditionSchema(Model.ColumnType.String)(condition), condition)
+	})
+
+	test('reject non-json condition for json type', () => {
+		const condition = {
+			eq: 'foo',
+		}
+		assert.throw(() => conditionSchema(Model.ColumnType.Json)(condition), 'value at root: extra property eq found')
+	})
+})

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

@@ -0,0 +1,161 @@
+import { assert, test } from 'vitest'
+import { MembershipResolver, MembershipValidationErrorType } from '../../../src'
+import { Acl } from '@contember/schema'
+
+const id1 = 'bff057b3-11f7-4bc7-abe3-1f2ef266824d'
+test('read membership with entity variable', () => {
+	const reader = new MembershipResolver()
+	const result = reader.resolve({
+		roles: {
+			editor: {
+				variables: {
+					localeID: { type: Acl.VariableType.entity, entityName: 'Locale' },
+				},
+				entities: {},
+			},
+		},
+	}, [
+		{ role: 'editor', variables: [{ name: 'localeID', values: [id1] }] },
+	], MembershipResolver.UnknownIdentity)
+	assert.lengthOf(result.errors, 0)
+	assert.deepStrictEqual(result.memberships, [
+		{ role: 'editor', variables: [{ name: 'localeID', condition: { in: [id1] } }] },
+	])
+})
+
+test('read fails when variable is not provided', () => {
+	const reader = new MembershipResolver()
+	const result = reader.resolve({
+		roles: {
+			editor: {
+				variables: {
+					localeID: { type: Acl.VariableType.entity, entityName: 'Locale' },
+				},
+				entities: {},
+			},
+		},
+	}, [
+		{ role: 'editor', variables: [] },
+	], MembershipResolver.UnknownIdentity)
+	assert.deepStrictEqual(result.errors, [{
+		error: MembershipValidationErrorType.VARIABLE_EMPTY,
+		role: 'editor',
+		variable: 'localeID',
+	}])
+
+	assert.deepStrictEqual(result.memberships, [
+		{ role: 'editor', variables: [{ name: 'localeID', condition: { never: true } }] },
+	])
+})
+
+test('read membership with predefined variable', () => {
+	const reader = new MembershipResolver()
+	const result = reader.resolve({
+		roles: {
+			editor: {
+				variables: {
+					self: { type: Acl.VariableType.predefined, value: 'identityID' },
+				},
+				entities: {},
+			},
+		},
+	}, [
+		{ role: 'editor', variables: [] },
+	], {
+		identityId: id1,
+	})
+	assert.lengthOf(result.errors, 0)
+	assert.deepStrictEqual(result.memberships, [
+		{ role: 'editor', variables: [{ name: 'self', condition: { in: [id1] } }] },
+	])
+})
+
+test('read membership with condition variable', () => {
+	const reader = new MembershipResolver()
+	const result = reader.resolve({
+		roles: {
+			editor: {
+				variables: {
+					cond: { type: Acl.VariableType.condition },
+				},
+				entities: {},
+			},
+		},
+	}, [
+		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify({ eq: 'foo' })] }] },
+	], MembershipResolver.UnknownIdentity)
+	assert.lengthOf(result.errors, 0)
+	assert.deepStrictEqual(result.memberships, [
+		{ role: 'editor', variables: [{ name: 'cond', condition: { eq: 'foo' } }] },
+	])
+})
+
+test('fails on invalid condition', () => {
+	const reader = new MembershipResolver()
+	const result = reader.resolve({
+		roles: {
+			editor: {
+				variables: {
+					cond: { type: Acl.VariableType.condition },
+				},
+				entities: {},
+			},
+		},
+	}, [
+		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
+	], MembershipResolver.UnknownIdentity)
+
+	assert.deepStrictEqual(result.errors, [{
+		error: MembershipValidationErrorType.VARIABLE_INVALID,
+		role: 'editor',
+		variable: 'cond',
+	}])
+
+	assert.deepStrictEqual(result.memberships, [
+		{ role: 'editor', variables: [{ name: 'cond', condition: { never: true } }] },
+	])
+})
+
+test('fails on undefined role', () => {
+	const reader = new MembershipResolver()
+	const result = reader.resolve({
+		roles: {
+		},
+	}, [
+		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
+	], {
+		identityId: id1,
+	})
+
+	assert.deepStrictEqual(result.errors, [{
+		error: MembershipValidationErrorType.ROLE_NOT_FOUND,
+		role: 'editor',
+		variable: undefined,
+	}])
+
+	assert.deepStrictEqual(result.memberships, [])
+})
+
+test('fails on undefined variable', () => {
+	const reader = new MembershipResolver()
+	const result = reader.resolve({
+		roles: {
+			editor: {
+				variables: {},
+				entities: {},
+			},
+		},
+	}, [
+		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
+	], MembershipResolver.UnknownIdentity)
+
+	assert.deepStrictEqual(result.errors, [{
+		error: MembershipValidationErrorType.VARIABLE_NOT_FOUND,
+		role: 'editor',
+		variable: 'cond',
+	}])
+
+	assert.deepStrictEqual(result.memberships, [
+		{ role: 'editor', variables: [] },
+	])
+})

package/tests/tsconfig.json

@@ -0,0 +1,12 @@
+{
+	"extends": "../tsconfig.settings.json",
+	"compilerOptions": {
+		"outDir": "../dist/tests",
+		"esModuleInterop": true
+	},
+	"references": [
+		{
+			"path": "../src"
+		}
+	]
+}

package/tsconfig.json

@@ -1,5 +1,12 @@
 {
 	"files": [],
 	"include": [],
-	"references": [{ "path": "./src" }]
+	"references": [
+		{
+			"path": "./src"
+		},
+		{
+			"path": "./tests"
+		}
+	]
 }