@contember/engine-content-api 1.1.0-alpha.3 → 1.1.0-alpha.6

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

@@ -1,10 +1,9 @@
 import { PredicateFactory, PredicatesInjector, VariableInjector } from '../../../src/acl'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Acl, Model } from '@contember/schema'
-import * as assert from 'uvu/assert'
-import { suite } from 'uvu'
+import { describe, it, assert } from 'vitest'
+
 
-const predicateInjectorTest = suite('Predicates injector')
 
 const schema = new SchemaBuilder()
 	.enum('locale', ['cs', 'en'])
@@ -43,71 +42,73 @@ const permissions: Acl.Permissions = {
 	},
 }
 
-predicateInjectorTest('injects predicate', () => {
-	const injector = new PredicatesInjector(
-		schema,
-		new PredicateFactory(permissions, new VariableInjector(schema, { localeVariable: ['cs'] })),
-	)
-	const result = injector.inject(schema.entities['PostLocale'], {})
+describe('Predicates injector', () => {
 
-	assert.equal(result, {
-		locale: { in: ['cs'] },
+	it('injects predicate', () => {
+		const injector = new PredicatesInjector(
+			schema,
+			new PredicateFactory(permissions, new VariableInjector(schema, { localeVariable: ['cs'] })),
+		)
+		const result = injector.inject(schema.entities['PostLocale'], {})
+
+		assert.deepStrictEqual(result, {
+			locale: { in: ['cs'] },
+		})
 	})
-})
 
-predicateInjectorTest('merges predicate with explicit where', () => {
-	const injector = new PredicatesInjector(
-		schema,
-		new PredicateFactory(permissions, new VariableInjector(schema, { localeVariable: ['cs'] })),
-	)
-	const result = injector.inject(schema.entities['PostLocale'], { id: { in: [1, 2] } })
+	it('merges predicate with explicit where', () => {
+		const injector = new PredicatesInjector(
+			schema,
+			new PredicateFactory(permissions, new VariableInjector(schema, { localeVariable: ['cs'] })),
+		)
+		const result = injector.inject(schema.entities['PostLocale'], { id: { in: [1, 2] } })
 
-	assert.equal(result, {
-		and: [
-			{
-				and: [
-					{
-						id: { in: [1, 2] },
-					},
-					{
-						locale: {
-							in: ['cs'],
+		assert.deepStrictEqual(result, {
+			and: [
+				{
+					and: [
+						{
+							id: { in: [1, 2] },
 						},
-					},
-				],
-			},
-			{
-				locale: { in: ['cs'] },
-			},
-		],
+						{
+							locale: {
+								in: ['cs'],
+							},
+						},
+					],
+				},
+				{
+					locale: { in: ['cs'] },
+				},
+			],
+		})
 	})
-})
 
-predicateInjectorTest('injects predicate to where', () => {
-	const injector = new PredicatesInjector(
-		schema,
-		new PredicateFactory(permissions, new VariableInjector(schema, { localeVariable: ['cs'] })),
-	)
+	it('injects predicate to where', () => {
+		const injector = new PredicatesInjector(
+			schema,
+			new PredicateFactory(permissions, new VariableInjector(schema, { localeVariable: ['cs'] })),
+		)
 
-	const result = injector.inject(schema.entities['PostLocale'], { title: { eq: 'abc' } })
+		const result = injector.inject(schema.entities['PostLocale'], { title: { eq: 'abc' } })
 
-	assert.equal(result, {
-		and: [
-			{
-				and: [
-					{
-						title: { eq: 'abc' },
-					},
-					{
-						locale: { in: ['cs'] },
-					},
-				],
-			},
-			{
-				locale: { in: ['cs'] },
-			},
-		],
+		assert.deepStrictEqual(result, {
+			and: [
+				{
+					and: [
+						{
+							title: { eq: 'abc' },
+						},
+						{
+							locale: { in: ['cs'] },
+						},
+					],
+				},
+				{
+					locale: { in: ['cs'] },
+				},
+			],
+		})
 	})
 })
 
-predicateInjectorTest.run()

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

@@ -1,70 +1,71 @@
 import { VariableInjector } from '../../../src/acl'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
-import * as assert from 'uvu/assert'
-import { suite } from 'uvu'
+import { describe, it, assert } from 'vitest'
 
-const variableInjectorTest = suite('Variable injector')
-variableInjectorTest('injects variable', () => {
-	const schema = new SchemaBuilder()
-		.enum('locale', ['cs', 'en'])
-		.entity('PostLocale', e =>
-			e
-				.column('locale', c => c.type(Model.ColumnType.Enum, { enumName: 'locale' }))
-				.column('foo', c => c.type(Model.ColumnType.String))
-				.column('public', c => c.type(Model.ColumnType.Bool))
-				.manyHasOne('post', r => r.target('Post', e => e.manyHasOne('site', r => r.target('Site', e => e)))),
-		)
-		.buildSchema()
+describe('Variable injector', () => {
 
-	const injector = new VariableInjector(schema, {
-		site: [1, 2],
-		locale: 'cs',
-	})
-	const result = injector.inject(schema.entities['PostLocale'], {
-		or: [
-			{
-				public: { eq: true },
-			},
-			{
-				and: [
-					{
-						post: {
-							site: 'site',
+	it('injects variable', () => {
+		const schema = new SchemaBuilder()
+			.enum('locale', ['cs', 'en'])
+			.entity('PostLocale', e =>
+				e
+					.column('locale', c => c.type(Model.ColumnType.Enum, { enumName: 'locale' }))
+					.column('foo', c => c.type(Model.ColumnType.String))
+					.column('public', c => c.type(Model.ColumnType.Bool))
+					.manyHasOne('post', r => r.target('Post', e => e.manyHasOne('site', r => r.target('Site', e => e)))),
+			)
+			.buildSchema()
+
+		const injector = new VariableInjector(schema, {
+			site: [1, 2],
+			locale: 'cs',
+		})
+		const result = injector.inject(schema.entities['PostLocale'], {
+			or: [
+				{
+					public: { eq: true },
+				},
+				{
+					and: [
+						{
+							post: {
+								site: 'site',
+							},
 						},
-					},
-					{
-						locale: 'locale',
-					},
-					{
-						foo: 'bar',
-					},
-				],
-			},
-		],
-	})
+						{
+							locale: 'locale',
+						},
+						{
+							foo: 'bar',
+						},
+					],
+				},
+			],
+		})
 
-	assert.equal(result, {
-		or: [
-			{
-				public: { eq: true },
-			},
-			{
-				and: [
-					{
-						post: {
-							site: { id: { in: [1, 2] } },
+		assert.deepStrictEqual(result, {
+			or: [
+				{
+					public: { eq: true },
+				},
+				{
+					and: [
+						{
+							post: {
+								site: { id: { in: [1, 2] } },
+							},
+						},
+						{
+							locale: { eq: 'cs' },
 						},
-					},
-					{
-						locale: { eq: 'cs' },
-					},
-					{
-						foo: { never: true },
-					},
-				],
-			},
-		],
+						{
+							foo: { never: true },
+						},
+					],
+				},
+			],
+		})
 	})
+
 })
-variableInjectorTest.run()

package/tests/src/testGraphql.ts

@@ -1,5 +1,5 @@
 import { graphql, GraphQLSchema } from 'graphql'
-import * as assert from 'uvu/assert'
+import { assert } from 'vitest'
 
 export interface Test {
 	schema: GraphQLSchema
@@ -13,11 +13,8 @@ export const executeGraphQlTest = async (test: Test) => {
 	const rawResponse = await graphql(test.schema, test.query, null, test.context, test.queryVariables)
 	const response = JSON.parse(JSON.stringify(rawResponse))
 	if ('errors' in rawResponse) {
-		if ((rawResponse.errors as any)[0]?.originalError instanceof assert.Assertion) {
-			throw (rawResponse.errors as any)[0].originalError
-		}
 		console.error((rawResponse.errors as any)[0])
 		rawResponse.errors = (rawResponse.errors as any).map(({ message }: any) => ({ message }))
 	}
-	assert.equal(response, test.return)
+	assert.deepStrictEqual(response, test.return)
 }

package/vite.config.js

@@ -0,0 +1,3 @@
+import { createViteConfig } from '../../scripts/vite/createViteConfig'
+
+export default createViteConfig()