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

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

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'bun:test'
+import { describe, expect, it } from 'bun:test'
 import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
 
 const assert = {
@@ -11,124 +11,169 @@ describe('condition optimizer', () => {
 	const optimizer = new ConditionOptimizer()
 
 	it('remove OR when only 1', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			or: [{ eq: 1 }],
-		}), { eq: 1 })
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				or: [{ eq: 1 }],
+			}),
+			{ eq: 1 },
+		)
 	})
 
 	it('keep OR when > 1', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			or: [{ eq: 1 }, { eq: 2 }],
-		}), {
-			or: [{ eq: 1 }, { eq: 2 }],
-		})
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				or: [{ eq: 1 }, { eq: 2 }],
+			}),
+			{
+				or: [{ eq: 1 }, { eq: 2 }],
+			},
+		)
 	})
 
 	it('keep never in OR', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			or: [{ never: true }],
-		}), false)
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				or: [{ never: true }],
+			}),
+			false,
+		)
 	})
 
 	it('optimizes OR with never', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			or: [{ eq: 1 }, { never: true }],
-		}), { eq: 1 })
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				or: [{ eq: 1 }, { never: true }],
+			}),
+			{ eq: 1 },
+		)
 	})
 
 	it('optimizes OR with always', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			or: [{ eq: 1 }, { always: true }],
-		}), true)
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				or: [{ eq: 1 }, { always: true }],
+			}),
+			true,
+		)
 	})
 
 	it('optimizes AND with never', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			and: [{ eq: 1 }, { never: true }],
-		}), false)
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				and: [{ eq: 1 }, { never: true }],
+			}),
+			false,
+		)
 	})
 
 	it('optimizes AND with always', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			and: [{ eq: 1 }, { always: true }],
-		}), { eq: 1 })
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				and: [{ eq: 1 }, { always: true }],
+			}),
+			{ eq: 1 },
+		)
 	})
 
 	it('optimizes NOT with never', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			not: { never: true },
-		}), true)
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				not: { never: true },
+			}),
+			true,
+		)
 	})
 
 	it('optimizes NOT with always', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			not: { always: true },
-		}), false)
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				not: { always: true },
+			}),
+			false,
+		)
 	})
 
 	it('optimizes empty AND', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			and: [],
-		}), {})
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				and: [],
+			}),
+			{},
+		)
 	})
 
 	it('optimizes empty OR', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			or: [],
-		}), {})
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				or: [],
+			}),
+			{},
+		)
 	})
 
-
 	it('flattens AND', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			eq: 0,
-			and: [
-				{ eq: 1 },
-				{
-					eq: 2,
-					and: [
-						{ eq: 3 },
-						{
-							eq: 4,
-							and: [{ eq: 5 }, { eq: 6 }],
-						},
-					],
-				},
-			],
-		}), { and: [{ eq: 0 }, { eq: 1 }, { eq: 2 }, { eq: 3 }, { eq: 4 }, { eq: 5 }, { eq: 6 }] })
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				eq: 0,
+				and: [
+					{ eq: 1 },
+					{
+						eq: 2,
+						and: [
+							{ eq: 3 },
+							{
+								eq: 4,
+								and: [{ eq: 5 }, { eq: 6 }],
+							},
+						],
+					},
+				],
+			}),
+			{ and: [{ eq: 0 }, { eq: 1 }, { eq: 2 }, { eq: 3 }, { eq: 4 }, { eq: 5 }, { eq: 6 }] },
+		)
 	})
 
 	it('flattens OR', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			or: [
-				{ eq: 1 },
-				{
-
-					or: [
-						{ eq: 2 },
-						{ or: [{ eq: 3 }, { eq: 4 }] },
-					],
-				},
-			],
-		}), { or: [{ eq: 1 }, { eq: 2 }, { eq: 3 }, { eq: 4 }] })
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				or: [
+					{ eq: 1 },
+					{
+						or: [
+							{ eq: 2 },
+							{ or: [{ eq: 3 }, { eq: 4 }] },
+						],
+					},
+				],
+			}),
+			{ or: [{ eq: 1 }, { eq: 2 }, { eq: 3 }, { eq: 4 }] },
+		)
 	})
 
 	it('flattens NOT', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			not: { not: { not: { eq: 1 } } },
-		}), { not: { eq: 1 } })
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				not: { not: { not: { eq: 1 } } },
+			}),
+			{ not: { eq: 1 } },
+		)
 	})
 
 	it('combine AND and OR', () => {
-		assert.deepStrictEqual(optimizer.optimize({
-			or: [
-				{ and: [{ eq: 1 }, { eq: 2 }] },
-				{ and: [{ eq: 3 }, { eq: 4 }], eq: 5 },
-			],
-		}), { or: [
-			{ and: [{ eq: 1 }, { eq: 2 }] },
-			{ and: [{ eq: 3 }, { eq: 4 }, { eq: 5 }] },
-		] })
+		assert.deepStrictEqual(
+			optimizer.optimize({
+				or: [
+					{ and: [{ eq: 1 }, { eq: 2 }] },
+					{ and: [{ eq: 3 }, { eq: 4 }], eq: 5 },
+				],
+			}),
+			{
+				or: [
+					{ and: [{ eq: 1 }, { eq: 2 }] },
+					{ and: [{ eq: 3 }, { eq: 4 }, { eq: 5 }] },
+				],
+			},
+		)
 	})
 
 	it('remove conditions with null value', () => {

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

@@ -1,9 +1,4 @@
-import {
-	ColumnValueResolver,
-	Dependencies,
-	InputPreValidator,
-	ValidationDataSelector,
-} from '../../../src/input-validation'
+import { ColumnValueResolver, Dependencies, InputPreValidator, ValidationDataSelector } from '../../../src/input-validation'
 import { InputValidation as v, SchemaBuilder, SchemaDefinition } from '@contember/schema-definition'
 import { Input, Model, Validation, Value } from '@contember/schema'
 import { EntityRulesResolver } from '../../../src'
@@ -27,7 +22,7 @@ const createDataSelectorMock = (primaryValues: PrimaryValueExpectation[], select
 	return createMock<ValidationDataSelector>({
 		getPrimaryValue: async (mapper: Mapper, entity: Model.Entity, where: Input.UniqueWhere) => {
 			const entry = primaryValues.shift()
-			//console.log(JSON.stringify({ entity: entity.name, where, result: undefined }))
+			// console.log(JSON.stringify({ entity: entity.name, where, result: undefined }))
 			if (!entry) {
 				throw new Error(`Unexpected getPrimaryValue call`)
 			}
@@ -51,7 +46,7 @@ const createDataSelectorMock = (primaryValues: PrimaryValueExpectation[], select
 			}
 			assert.equal(entity.name, entry.entity)
 			assert.deepStrictEqual(where, entry.where)
-			//console.log(JSON.stringify(entry))
+			// console.log(JSON.stringify(entry))
 			assert.deepStrictEqual(dependencies, entry.dependencies)
 			return entry.result
 		},
@@ -80,7 +75,6 @@ const createValidator = ({
 	)
 const mapper = {} as Mapper
 
-
 namespace ViewModelDefinition {
 	export class Book {
 		title = def.stringColumn()
@@ -94,10 +88,7 @@ namespace ViewModelDefinition {
 	}
 }
 
-
 describe('Input pre-validator', () => {
-
-
 	it('validates implicit rules', async () => {
 		const model = new SchemaBuilder()
 			.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
@@ -244,8 +235,7 @@ describe('Input pre-validator', () => {
 			.entity('Book', e =>
 				e
 					.column('title', c => c.notNull().type(Model.ColumnType.String))
-					.manyHasOne('author', r => r.target('Author', e => e.column('name')).notNull()),
-			)
+					.manyHasOne('author', r => r.target('Author', e => e.column('name')).notNull()))
 			.buildSchema()
 
 		const validator = createValidator({ model, validation: {} })
@@ -392,8 +382,7 @@ describe('Input pre-validator', () => {
 			.entity('Article', e =>
 				e
 					.column('publishedAt', c => c.type(Model.ColumnType.DateTime))
-					.manyHasOne('image', image => image.target('Image', e => e.column('url'))),
-			)
+					.manyHasOne('image', image => image.target('Image', e => e.column('url'))))
 			.buildSchema()
 
 		const rule = v.rules.conditional(v.rules.on('publishedAt', v.rules.notNull()), v.rules.defined())
@@ -436,7 +425,6 @@ describe('Input pre-validator', () => {
 		])
 	})
 
-
 	it('ignore not null on view relation', async () => {
 		const model = SchemaDefinition.createModel(ViewModelDefinition)
 

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

@@ -14,8 +14,6 @@ import { describe, expect, it } from 'bun:test'
 import { assert } from '../../src/assert'
 
 describe('input validation tests', () => {
-
-
 	it('evaluates rule', () => {
 		const r = validation.rules
 		const rule = r.conditional(
@@ -106,14 +104,12 @@ describe('input validation tests', () => {
 				e
 					.column('deleted', c => c.type(Model.ColumnType.Bool))
 					.column('published', c => c.type(Model.ColumnType.Bool))
-					.manyHasOne('category', r => r.target('Category')),
-			)
+					.manyHasOne('category', r => r.target('Category')))
 			.entity('Category', e => e.column('name'))
 			.entity('Author', e =>
 				e
 					.oneHasMany('books', r => r.target('Book').ownedBy('author'))
-					.column('published', c => c.type(Model.ColumnType.Bool)),
-			)
+					.column('published', c => c.type(Model.ColumnType.Bool)))
 			.buildSchema()
 		const dependencies: Dependencies = {
 			books: {
@@ -165,7 +161,6 @@ describe('input validation tests', () => {
 	})
 
 	describe('validation - trinary logic', () => {
-
 		it('trinary "and" results in a null', () => {
 			const rule = validation.rules.and(
 				validation.rules.on('email', validation.rules.pattern(/.+@.+/)),

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

@@ -16,8 +16,6 @@ const entity: Model.Entity = {
 }
 
 describe('order by helper', () => {
-
-
 	it('set default order by without defined order', () => {
 		const objectNode = new ObjectNode('test', 'test', [], {}, {}, [])
 
@@ -73,10 +71,14 @@ describe('order by helper', () => {
 	it('set default order by without defined order', () => {
 		const objectNode = new ObjectNode('test', 'test', [], {}, {}, [])
 
-		const newNode = OrderByHelper.appendDefaultOrderBy({
-			...entity,
-			orderBy: [{ path: ['lorem', 'ipsum'], direction: Input.OrderDirection.desc }],
-		}, objectNode, undefined)
+		const newNode = OrderByHelper.appendDefaultOrderBy(
+			{
+				...entity,
+				orderBy: [{ path: ['lorem', 'ipsum'], direction: Input.OrderDirection.desc }],
+			},
+			objectNode,
+			undefined,
+		)
 		assert.deepStrictEqual(newNode.args.orderBy, [
 			{ lorem: { ipsum: Input.OrderDirection.desc } },
 			{ id: Input.OrderDirection.asc },

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

@@ -11,6 +11,13 @@ interface Test {
 	result: Acl.Permissions
 }
 
+interface ContextualTest {
+	acl: Acl.Schema
+	roles: string[]
+	rootResult: Acl.Permissions
+	allResult: Acl.Permissions
+}
+
 const execute = (test: Test) => {
 	const model: Model.Schema = new SchemaBuilder()
 		.entity('Entity1', e => e.column('lorem').column('bar'))
@@ -20,15 +27,29 @@ const execute = (test: Test) => {
 	const initialAcl = JSON.parse(JSON.stringify(test.acl))
 	const result = merger.create({
 		...emptySchema,
-		 model,
+		model,
 		acl: test.acl,
 	}, test.roles)
 	assert.deepStrictEqual(result, test.result)
 	assert.deepStrictEqual(test.acl, initialAcl)
 }
 
-describe('Permission merger', () => {
+const executeContextual = (test: ContextualTest) => {
+	const model: Model.Schema = new SchemaBuilder()
+		.entity('Entity1', e => e.column('lorem').column('bar'))
+		.entity('Entity2', e => e.oneHasOne('xyz', r => r.target('Entity1')))
+		.buildSchema()
+	const factory = new PermissionFactory()
+	const { root, all } = factory.createContextual({
+		...emptySchema,
+		model,
+		acl: test.acl,
+	}, test.roles)
+	assert.deepStrictEqual(root, test.rootResult)
+	assert.deepStrictEqual(all, test.allResult)
+}
 
+describe('Permission merger', () => {
 	it('merge inheritance', () => {
 		execute({
 			acl: {
@@ -549,7 +570,6 @@ describe('Permission merger', () => {
 		})
 	})
 
-
 	it('merge noRootOperations', () => {
 		execute({
 			acl: {
@@ -607,7 +627,6 @@ describe('Permission merger', () => {
 		})
 	})
 
-
 	it('merge delete #1', () => {
 		execute({
 			acl: {
@@ -648,7 +667,6 @@ describe('Permission merger', () => {
 		})
 	})
 
-
 	it('merge delete #2', () => {
 		execute({
 			acl: {
@@ -730,7 +748,6 @@ describe('Permission merger', () => {
 		})
 	})
 
-
 	it('prefer permissions with root allowed', () => {
 		execute({
 			acl: {
@@ -789,7 +806,6 @@ describe('Permission merger', () => {
 		})
 	})
 
-
 	it('merge permissions with no root', () => {
 		execute({
 			acl: {
@@ -851,3 +867,143 @@ describe('Permission merger', () => {
 		})
 	})
 })
+
+describe('Contextual permission merger', () => {
+	it('createContextual: root drops through-only, all includes both', () => {
+		executeContextual({
+			acl: {
+				roles: {
+					throughRole: {
+						variables: {},
+						entities: {
+							Entity2: {
+								predicates: {
+									foo: { xyz: { lorem: { eq: 'through' } } },
+								},
+								operations: {
+									read: {
+										title: 'foo',
+									},
+									noRoot: ['read'],
+								},
+							},
+						},
+					},
+					rootRole: {
+						variables: {},
+						entities: {
+							Entity2: {
+								predicates: {
+									bar: { xyz: { lorem: { eq: 'root' } } },
+								},
+								operations: {
+									read: {
+										title: 'bar',
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			roles: ['throughRole', 'rootRole'],
+			rootResult: {
+				Entity2: {
+					operations: {
+						read: {
+							title: 'bar',
+							id: 'bar',
+						},
+					},
+					predicates: {
+						bar: {
+							xyz: {
+								lorem: { eq: 'root' },
+							},
+						},
+					},
+				},
+			},
+			allResult: {
+				Entity2: {
+					operations: {
+						read: {
+							title: '__merge__foo__bar',
+							id: '__merge__foo__bar',
+						},
+					},
+					predicates: {
+						__merge__foo__bar: {
+							or: [
+								{ xyz: { lorem: { eq: 'through' } } },
+								{ xyz: { lorem: { eq: 'root' } } },
+							],
+						},
+					},
+				},
+			},
+		})
+	})
+
+	it('createContextual: both roles without noRoot produce same root and all', () => {
+		executeContextual({
+			acl: {
+				roles: {
+					role1: {
+						variables: {},
+						entities: {
+							Entity1: {
+								predicates: {},
+								operations: {
+									read: {
+										id: true,
+										lorem: true,
+									},
+								},
+							},
+						},
+					},
+					role2: {
+						variables: {},
+						entities: {
+							Entity1: {
+								predicates: {},
+								operations: {
+									read: {
+										id: true,
+										bar: true,
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			roles: ['role1', 'role2'],
+			rootResult: {
+				Entity1: {
+					predicates: {},
+					operations: {
+						read: {
+							id: true,
+							lorem: true,
+							bar: true,
+						},
+					},
+				},
+			},
+			allResult: {
+				Entity1: {
+					predicates: {},
+					operations: {
+						read: {
+							id: true,
+							lorem: true,
+							bar: true,
+						},
+					},
+				},
+			},
+		})
+	})
+})

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

@@ -71,6 +71,28 @@ const permissions: Acl.Permissions = {
 	},
 }
 
+const throughPermissions: Acl.Permissions = {
+	Author: {
+		predicates: {
+			authorPredicate: {
+				isPublic: { eq: true },
+			},
+			throughPredicate: {
+				name: { eq: 'through' },
+			},
+		},
+		operations: {
+			read: {
+				id: '__merge__authorPredicate__throughPredicate',
+				name: '__merge__authorPredicate__throughPredicate',
+				image: '__merge__authorPredicate__throughPredicate',
+			},
+		},
+	},
+	Article: permissions.Article,
+	Image: permissions.Image,
+}
+
 describe('Predicates factory', () => {
 	const schema = def.createModel(TestModel)
 
@@ -100,5 +122,57 @@ describe('Predicates factory', () => {
 			],
 		})
 	})
-})
 
+	it('uses root permissions when isRoot is true', () => {
+		const predicateFactory = new PredicateFactory(permissions, schema, new VariableInjector(schema, {}), throughPermissions)
+		const author = schema.entities['Author']
+		const predicate = predicateFactory.create(author, Acl.Operation.read, ['name'], undefined, true)
+		assert.deepStrictEqual(predicate, {
+			isPublic: { eq: true },
+		})
+	})
+
+	it('uses root permissions when isRoot is undefined', () => {
+		const predicateFactory = new PredicateFactory(permissions, schema, new VariableInjector(schema, {}), throughPermissions)
+		const author = schema.entities['Author']
+		const predicate = predicateFactory.create(author, Acl.Operation.read, ['name'], undefined, undefined)
+		assert.deepStrictEqual(predicate, {
+			isPublic: { eq: true },
+		})
+	})
+
+	it('uses allPermissions when isRoot is false', () => {
+		const allPerms: Acl.Permissions = {
+			...permissions,
+			Author: {
+				predicates: {
+					allPredicate: {
+						name: { eq: 'all' },
+					},
+				},
+				operations: {
+					read: {
+						id: 'allPredicate',
+						name: 'allPredicate',
+						image: 'allPredicate',
+					},
+				},
+			},
+		}
+		const predicateFactory = new PredicateFactory(permissions, schema, new VariableInjector(schema, {}), allPerms)
+		const author = schema.entities['Author']
+		const predicate = predicateFactory.create(author, Acl.Operation.read, ['name'], undefined, false)
+		assert.deepStrictEqual(predicate, {
+			name: { eq: 'all' },
+		})
+	})
+
+	it('falls back to root permissions when allPermissions is not provided', () => {
+		const predicateFactory = new PredicateFactory(permissions, schema, new VariableInjector(schema, {}))
+		const author = schema.entities['Author']
+		const predicate = predicateFactory.create(author, Acl.Operation.read, ['name'], undefined, false)
+		assert.deepStrictEqual(predicate, {
+			isPublic: { eq: true },
+		})
+	})
+})