@contember/schema-utils 2.1.0-alpha.9 → 2.1.0-beta.2

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

@@ -3,20 +3,26 @@ import { MembershipResolver, MembershipValidationErrorType } from '../../../src'
 import { Acl } from '@contember/schema'
 
 const id1 = 'bff057b3-11f7-4bc7-abe3-1f2ef266824d'
+const id2 = '1cdb828f-62f0-4ae5-9b2c-e53b3e7584ef'
 test('read membership with entity variable', () => {
 	const reader = new MembershipResolver()
-	const result = reader.resolve({
-		roles: {
-			editor: {
-				variables: {
-					localeID: { type: Acl.VariableType.entity, entityName: 'Locale' },
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {
+						localeID: { type: Acl.VariableType.entity, entityName: 'Locale' },
+					},
+					entities: {},
 				},
-				entities: {},
 			},
 		},
-	}, [
-		{ role: 'editor', variables: [{ name: 'localeID', values: [id1] }] },
-	], MembershipResolver.UnknownIdentity)
+		[
+			{ role: 'editor', variables: [{ name: 'localeID', values: [id1] }] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 	expect(result.errors).toStrictEqual([])
 	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'localeID', condition: { in: [id1] } }] },
@@ -25,18 +31,23 @@ test('read membership with entity variable', () => {
 
 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' },
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {
+						localeID: { type: Acl.VariableType.entity, entityName: 'Locale' },
+					},
+					entities: {},
 				},
-				entities: {},
 			},
 		},
-	}, [
-		{ role: 'editor', variables: [] },
-	], MembershipResolver.UnknownIdentity)
+		[
+			{ role: 'editor', variables: [] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_EMPTY,
 		role: 'editor',
@@ -63,7 +74,7 @@ test('read membership with predefined variable', () => {
 		{ role: 'editor', variables: [] },
 	], {
 		identityId: id1,
-	})
+	}, false)
 	expect(result.errors).toStrictEqual([])
 	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'self', condition: { in: [id1] } }] },
@@ -71,39 +82,107 @@ test('read membership with predefined variable', () => {
 })
 
 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,
+		false,
+	)
+	expect(result.errors).toStrictEqual([])
+	expect(result.memberships).toStrictEqual([
+		{ role: 'editor', variables: [{ name: 'cond', condition: { eq: 'foo' } }] },
+	])
+})
+
+test('fails when trying to override predefined variable with stored', () => {
 	const reader = new MembershipResolver()
 	const result = reader.resolve({
 		roles: {
 			editor: {
 				variables: {
-					cond: { type: Acl.VariableType.condition },
+					self: { type: Acl.VariableType.predefined, value: 'identityID' },
 				},
 				entities: {},
 			},
 		},
 	}, [
-		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify({ eq: 'foo' })] }] },
-	], MembershipResolver.UnknownIdentity)
-	expect(result.errors).toStrictEqual([])
+		{
+			role: 'editor',
+			variables: [
+				{ name: 'self', values: [id2] },
+			],
+		},
+	], {
+		identityId: id1,
+	}, false)
+	expect(result.errors).toEqual([{
+		error: MembershipValidationErrorType.VARIABLE_NOT_FOUND,
+		role: 'editor',
+		variable: 'self',
+	}])
 	expect(result.memberships).toStrictEqual([
-		{ role: 'editor', variables: [{ name: 'cond', condition: { eq: 'foo' } }] },
+		{ role: 'editor', variables: [{ name: 'self', condition: { in: [id1] } }] },
 	])
 })
 
-test('fails on invalid condition', () => {
+test('read overridden predefined variable with assume', () => {
 	const reader = new MembershipResolver()
 	const result = reader.resolve({
 		roles: {
 			editor: {
 				variables: {
-					cond: { type: Acl.VariableType.condition },
+					self: { type: Acl.VariableType.predefined, value: 'identityID' },
 				},
 				entities: {},
 			},
 		},
 	}, [
-		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
-	], MembershipResolver.UnknownIdentity)
+		{
+			role: 'editor',
+			variables: [
+				{ name: 'self', values: [id2] },
+			],
+		},
+	], {
+		identityId: id1,
+	}, true)
+	expect(result.errors).toEqual([])
+	expect(result.memberships).toStrictEqual([
+		{ role: 'editor', variables: [{ name: 'self', condition: { in: [id2] } }] },
+	])
+})
+
+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,
+		false,
+	)
 
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_INVALID,
@@ -119,13 +198,12 @@ test('fails on invalid condition', () => {
 test('fails on undefined role', () => {
 	const reader = new MembershipResolver()
 	const result = reader.resolve({
-		roles: {
-		},
+		roles: {},
 	}, [
 		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
 	], {
 		identityId: id1,
-	})
+	}, false)
 
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.ROLE_NOT_FOUND,
@@ -138,16 +216,21 @@ test('fails on undefined role', () => {
 
 test('fails on undefined variable', () => {
 	const reader = new MembershipResolver()
-	const result = reader.resolve({
-		roles: {
-			editor: {
-				variables: {},
-				entities: {},
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {},
+					entities: {},
+				},
 			},
 		},
-	}, [
-		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
-	], MembershipResolver.UnknownIdentity)
+		[
+			{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_NOT_FOUND,
@@ -160,21 +243,25 @@ test('fails on undefined variable', () => {
 	])
 })
 
-
 test('use fallback value', () => {
 	const reader = new MembershipResolver()
-	const result = reader.resolve({
-		roles: {
-			editor: {
-				variables: {
-					localeID: { type: Acl.VariableType.condition, fallback: { always: true } },
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {
+						localeID: { type: Acl.VariableType.condition, fallback: { always: true } },
+					},
+					entities: {},
 				},
-				entities: {},
 			},
 		},
-	}, [
-		{ role: 'editor', variables: [] },
-	], MembershipResolver.UnknownIdentity)
+		[
+			{ role: 'editor', variables: [] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 	expect(result.errors).toStrictEqual([])
 
 	expect(result.memberships).toStrictEqual([

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

@@ -1,4 +1,4 @@
-import { expect, describe, test } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 import { modelSchema } from '../../../src/type-schema'
 import { Model } from '@contember/schema'
 
@@ -17,9 +17,9 @@ describe('model schema', () => {
 
 	// Array of invalid PostgreSQL data type examples
 	const invalidDataTypes = [
-		'varchar(255',           // Missing closing parenthesis
-		'character(10))',        // Extra closing parenthesis
-		'numeric(,2)',           // Missing first parameter
+		'varchar(255', // Missing closing parenthesis
+		'character(10))', // Extra closing parenthesis
+		'numeric(,2)', // Missing first parameter
 		'geometry(Point,4326))', // Extra closing parenthesis
 		'VARCHAR(255) COLLATE "de_DE" (extra text)', // Extra text outside the valid pattern
 		'VARCHAR(255) COLLATE "de_DE', // Missing closing quote

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

@@ -92,7 +92,6 @@ test('column name collision', () => {
 	])
 })
 
-
 namespace ViewRelations {
 	@c.View('SELECT 1')
 	export class Foo {

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

@@ -7,7 +7,7 @@ describe('printJsValue', () => {
 	})
 
 	test('string escape', () => {
-		expect(printJsValue('foo\'bar')).toEqual(`'foo\\'bar'`)
+		expect(printJsValue("foo'bar")).toEqual(`'foo\\'bar'`)
 	})
 
 	test('number', () => {
@@ -31,7 +31,8 @@ describe('printJsValue', () => {
 	1,
 	2,
 	3,
-]`)
+]`,
+		)
 	})
 
 	test('inline object', () => {
@@ -43,7 +44,8 @@ describe('printJsValue', () => {
 			`{
 	a: 1,
 	b: 2,
-}`)
+}`,
+		)
 	})
 
 	test('nested block object', () => {
@@ -57,16 +59,17 @@ describe('printJsValue', () => {
 			},
 		},
 	},
-}`)
+}`,
+		)
 	})
 
-
 	test('one level nested block object', () => {
 		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, (_, path) => path.length === 0)).toEqual(
 			`{
 	a: 1,
 	b: { c: { d: { e: 1 } } },
-}`)
+}`,
+		)
 	})
 
 	test('nested block object and arr', () => {
@@ -83,6 +86,7 @@ describe('printJsValue', () => {
 			6,
 		],
 	],
-}`)
+}`,
+		)
 	})
 })

package/tests/cases/unit/whereSchema.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'
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
@@ -43,7 +43,6 @@ describe('where schema', () => {
 		expect(whereSchema({ schema, entity: schema.entities.Article })(where)).toStrictEqual(where)
 	})
 
-
 	test('where with relation', () => {
 		const where = {
 			tags: { name: { eq: 'xx' } },
@@ -55,35 +54,37 @@ describe('where schema', () => {
 		const where = {
 			name: { eq: 'foo' },
 		}
-		expect(() => whereSchema({
-			schema,
-			entity: schema.entities.Article,
-		})(where)).toThrow('value at root: extra property name found')
+		expect(() =>
+			whereSchema({
+				schema,
+				entity: schema.entities.Article,
+			})(where)
+		).toThrow('value at root: extra property name found')
 	})
 
-
 	test('undefined field in relation', () => {
 		const where = {
 			tags: {
 				caption: { eq: 'foo' },
-
 			},
 		}
-		expect(() => whereSchema({
-			schema,
-			entity: schema.entities.Article,
-		})(where)).toThrow('value at path /tags: extra property caption found')
+		expect(() =>
+			whereSchema({
+				schema,
+				entity: schema.entities.Article,
+			})(where)
+		).toThrow('value at path /tags: extra property caption found')
 	})
 
-
 	test('invalid condition', () => {
 		const where = {
 			title: { xx: 'foo' },
 		}
-		expect(() => whereSchema({
-			schema,
-			entity: schema.entities.Article,
-		})(where)).toThrow('value at path /title: extra property xx found')
+		expect(() =>
+			whereSchema({
+				schema,
+				entity: schema.entities.Article,
+			})(where)
+		).toThrow('value at path /title: extra property xx found')
 	})
-
 })

package/tests/cases/unit/schemas/.eslintignore

@@ -1 +0,0 @@
-*.ts

package/vitest.config.ts

@@ -1,3 +0,0 @@
-import { defineProject } from 'vitest/config'
-
-export default defineProject({})