@contember/engine-content-api 2.1.0-alpha.8 → 2.1.0-beta.1

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

@@ -20,7 +20,7 @@ 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)
@@ -28,7 +28,6 @@ const execute = (test: Test) => {
 }
 
 describe('Permission merger', () => {
-
 	it('merge inheritance', () => {
 		execute({
 			acl: {
@@ -549,7 +548,6 @@ describe('Permission merger', () => {
 		})
 	})
 
-
 	it('merge noRootOperations', () => {
 		execute({
 			acl: {
@@ -607,7 +605,6 @@ describe('Permission merger', () => {
 		})
 	})
 
-
 	it('merge delete #1', () => {
 		execute({
 			acl: {
@@ -648,7 +645,6 @@ describe('Permission merger', () => {
 		})
 	})
 
-
 	it('merge delete #2', () => {
 		execute({
 			acl: {
@@ -730,7 +726,6 @@ describe('Permission merger', () => {
 		})
 	})
 
-
 	it('prefer permissions with root allowed', () => {
 		execute({
 			acl: {
@@ -789,7 +784,6 @@ describe('Permission merger', () => {
 		})
 	})
 
-
 	it('merge permissions with no root', () => {
 		execute({
 			acl: {

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

@@ -101,4 +101,3 @@ describe('Predicates factory', () => {
 		})
 	})
 })
-