@contember/schema-utils 2.1.0-alpha.30 → 2.1.0-alpha.35

package/src/validation/AclValidator.ts

@@ -4,7 +4,6 @@ import { getEntity } from '../model'
 import { ErrorBuilder, ValidationError } from './errors'
 import { conditionSchema } from '../type-schema'
 
-
 export class AclValidator {
 	constructor(private readonly model: Model.Schema) {}
 
@@ -28,7 +27,6 @@ export class AclValidator {
 		roles: string[],
 		errorBuilder: ErrorBuilder,
 	): void {
-
 		this.validateInherits(permissions.inherits, roles, errorBuilder.for('inherits'))
 		this.validateVariables(permissions.variables, errorBuilder.for('variables'))
 		this.validatePermissions(permissions.entities, (permissions.variables as Acl.Variables) || {}, errorBuilder.for('entities'))

package/src/validation/ActionsValidator.ts

@@ -5,12 +5,13 @@ import { assertNever } from '../utils'
 import * as Typesafe from '@contember/typesafe'
 import { whereSchema } from '../type-schema/where'
 
-const manyArgsSchema = (args: {schema: Model.Schema; entity: Model.Entity}) => Typesafe.partial({
-	limit: Typesafe.integer,
-	offset: Typesafe.integer,
-	orderBy: Typesafe.array(Typesafe.anyJsonObject),
-	filter: whereSchema(args),
-})
+const manyArgsSchema = (args: { schema: Model.Schema; entity: Model.Entity }) =>
+	Typesafe.partial({
+		limit: Typesafe.integer,
+		offset: Typesafe.integer,
+		orderBy: Typesafe.array(Typesafe.anyJsonObject),
+		filter: whereSchema(args),
+	})
 
 export class ActionsValidator {
 	constructor(private readonly model: Model.Schema) {}
@@ -34,7 +35,6 @@ export class ActionsValidator {
 		}
 	}
 
-
 	private validateTrigger(trigger: Actions.AnyTrigger, errorBuilder: ErrorBuilder): void {
 		const entity = this.model.entities[trigger.entity]
 		if (!entity) {

package/src/validation/MembershipResolver.ts

@@ -3,7 +3,6 @@ import { getRoleVariables } from '../acl'
 import { conditionSchema } from '../type-schema'
 import { assertNever } from '../utils'
 
-
 export class MembershipResolver {
 	public static UnknownIdentity = { identityId: '00000000-0000-0000-0000-000000000000' }
 
@@ -88,7 +87,6 @@ export class MembershipResolver {
 
 			if (variable.type === Acl.VariableType.entity) {
 				parsedVariables.push({ name, condition: { in: inputVariable.values } }) // todo: cast to int where primary is int
-
 			} else if (variable.type === Acl.VariableType.condition) {
 				try {
 					const conditions = inputVariable.values.map(it => conditionSchema()(JSON.parse(it)))
@@ -132,7 +130,6 @@ export enum MembershipValidationErrorType {
 	VARIABLE_INVALID = 'variableInvalid',
 }
 
-
 export interface ParsedMembershipVariable {
 	readonly name: string
 	readonly condition: Input.Condition

package/src/validation/ModelValidator.ts

@@ -5,9 +5,8 @@ import { acceptEveryFieldVisitor, getTargetEntity, isColumn, isInverseRelation,
 const IDENTIFIER_PATTERN = /^[_a-zA-Z][_a-zA-Z0-9]*$/
 const RESERVED_WORDS = ['and', 'or', 'not']
 
-
 export class ModelValidator {
-	constructor(private readonly model: Model.Schema) { }
+	constructor(private readonly model: Model.Schema) {}
 
 	public validate(): ValidationError[] {
 		const errorBuilder = new ErrorBuilder([], [])
@@ -121,7 +120,7 @@ export class ModelValidator {
 			return errors.add('MODEL_UNDEFINED_ENTITY', `Target entity ${targetEntityName} not found`)
 		}
 		if (((it: Model.AnyRelation): it is Model.AnyRelation & Model.OrderableRelation => 'orderBy' in it)(field)) {
-			(field as Model.OrderableRelation).orderBy?.forEach(it => {
+			;(field as Model.OrderableRelation).orderBy?.forEach(it => {
 				let entity = targetEntity
 
 				for (let i = 0; i < it.path.length; i++) {
@@ -147,15 +146,15 @@ export class ModelValidator {
 				return errors.add('MODEL_INVALID_VIEW_USAGE', 'Many-has-many relation is not allowed on a view entity.')
 			}
 			if (
-				!targetEntity.view &&
-				field.type === Model.RelationType.OneHasMany
+				!targetEntity.view
+				&& field.type === Model.RelationType.OneHasMany
 			) {
 				return errors.add('MODEL_INVALID_VIEW_USAGE', 'One-has-many relation fields on views must point to a view entity.')
 			}
 			if (
-				!targetEntity.view &&
-				field.type === Model.RelationType.OneHasOne &&
-				!('joiningColumn' in field)
+				!targetEntity.view
+				&& field.type === Model.RelationType.OneHasOne
+				&& !('joiningColumn' in field)
 			) {
 				return errors.add('MODEL_INVALID_VIEW_USAGE', 'One-has-one relation fields on views must be owning or point to a view entity.')
 			}
@@ -172,7 +171,10 @@ export class ModelValidator {
 				return errors.add('MODEL_RELATION_REQUIRED', `${relationDescription} not a relation`)
 			}
 			if (targetField.target !== entityName) {
-				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference to entity ${entityName} expected, but ${targetField.target} given`)
+				return errors.add(
+					'MODEL_INVALID_RELATION_DEFINITION',
+					`${relationDescription} back reference to entity ${entityName} expected, but ${targetField.target} given`,
+				)
 			}
 			if (!isOwningRelation(targetField)) {
 				errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} not an owning relation`)
@@ -182,7 +184,10 @@ export class ModelValidator {
 				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} inverse relation is not set`)
 			}
 			if (targetField.inversedBy !== field.name) {
-				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.inversedBy} given`)
+				return errors.add(
+					'MODEL_INVALID_RELATION_DEFINITION',
+					`${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.inversedBy} given`,
+				)
 			}
 			if (field.type === Model.RelationType.OneHasOne && targetField.type !== Model.RelationType.OneHasOne) {
 				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} "OneHasOne" type expected, "${targetField.type}" given`)
@@ -205,7 +210,10 @@ export class ModelValidator {
 					return errors.add('MODEL_RELATION_REQUIRED', `${relationDescription} not a relation`)
 				}
 				if (targetField.target !== entityName) {
-					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference to entity ${entityName} expected, but ${targetField.target} given`)
+					return errors.add(
+						'MODEL_INVALID_RELATION_DEFINITION',
+						`${relationDescription} back reference to entity ${entityName} expected, but ${targetField.target} given`,
+					)
 				}
 				if (!isInverseRelation(targetField)) {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} not an inverse relation`)
@@ -214,7 +222,10 @@ export class ModelValidator {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} owning relation is not set`)
 				}
 				if (targetField.ownedBy !== field.name) {
-					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.ownedBy} given`)
+					return errors.add(
+						'MODEL_INVALID_RELATION_DEFINITION',
+						`${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.ownedBy} given`,
+					)
 				}
 				if (field.type === Model.RelationType.OneHasOne && targetField.type !== Model.RelationType.OneHasOne) {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} "OneHasOne" type expected, "${targetField.type}" given`)
@@ -244,7 +255,6 @@ export class ModelValidator {
 		}
 	}
 
-
 	private validateMetaSuffixCollisions(entities: Model.Entity[], errorBuilder: ErrorBuilder) {
 		const entityNames = new Set(entities.map(it => it.name))
 		for (const entity of entities) {
@@ -252,13 +262,15 @@ export class ModelValidator {
 				const baseName = entity.name.substring(0, entity.name.length - 4)
 				if (entityNames.has(baseName)) {
 					errorBuilder.for(entity.name)
-						.add('MODEL_NAME_COLLISION', `entity ${entity.name} collides with entity ${baseName}, because a GraphQL type with "Meta" suffix is created for every entity`)
+						.add(
+							'MODEL_NAME_COLLISION',
+							`entity ${entity.name} collides with entity ${baseName}, because a GraphQL type with "Meta" suffix is created for every entity`,
+						)
 				}
 			}
 		}
 	}
 
-
 	private validateTableNameCollisions(entities: Model.Entity[], errorBuilder: ErrorBuilder) {
 		const relationNames: Record<string, string> = {}
 		for (const entity of entities) {
@@ -280,25 +292,25 @@ export class ModelValidator {
 					if (relationNames[joiningTable.tableName]) {
 						entityErrorBuilder
 							.for(relation.name)
-							.add('MODEL_NAME_COLLISION',
-								`${description} collides with a ${relationNames[joiningTable.tableName]}.` +
-								'Consider using plural for a relation name or change the joining table name using .joiningTable(...) in schema definition.',
+							.add(
+								'MODEL_NAME_COLLISION',
+								`${description} collides with a ${relationNames[joiningTable.tableName]}.`
+									+ 'Consider using plural for a relation name or change the joining table name using .joiningTable(...) in schema definition.',
 							)
 					} else {
 						relationNames[joiningTable.tableName] = description
 					}
 				},
 				visitColumn: () => {},
-				visitManyHasManyInverse: () => { },
-				visitOneHasMany: () => { },
-				visitOneHasOneInverse: () => { },
-				visitOneHasOneOwning: () => { },
-				visitManyHasOne: () => { },
+				visitManyHasManyInverse: () => {},
+				visitOneHasMany: () => {},
+				visitOneHasOneInverse: () => {},
+				visitOneHasOneOwning: () => {},
+				visitManyHasOne: () => {},
 			})
 		}
 	}
 
-
 	private validateAliasedTypesCollision(entities: Model.Entity[], errorBuilder: ErrorBuilder) {
 		const aliasedTypes = new Map<string, Model.ColumnType>()
 		for (const entity of entities) {
@@ -314,16 +326,15 @@ export class ModelValidator {
 					}
 					aliasedTypes.set(column.typeAlias, column.type)
 				},
-				visitManyHasManyOwning: () => { },
-				visitManyHasManyInverse: () => { },
-				visitOneHasMany: () => { },
-				visitOneHasOneInverse: () => { },
-				visitOneHasOneOwning: () => { },
-				visitManyHasOne: () => { },
+				visitManyHasManyOwning: () => {},
+				visitManyHasManyInverse: () => {},
+				visitOneHasMany: () => {},
+				visitOneHasOneInverse: () => {},
+				visitOneHasOneOwning: () => {},
+				visitManyHasOne: () => {},
 			})
 		}
 	}
 }
 
-const isRelation = (field: Model.AnyField): field is Model.AnyRelation =>
-	Object.values(Model.RelationType).includes(field.type as Model.RelationType)
+const isRelation = (field: Model.AnyField): field is Model.AnyRelation => Object.values(Model.RelationType).includes(field.type as Model.RelationType)

package/src/validation/SchemaValidator.ts

@@ -19,22 +19,23 @@ export class SchemaValidator {
 		const aclValidator = new AclValidator(schema.model)
 		const aclErrors = aclValidator.validate(schema.acl)
 
-
 		const validationValidator = new ValidationValidator(schema.model)
 		const validationErrors = validationValidator.validate(schema.validation)
 
 		const actionsValidator = new ActionsValidator(schema.model)
-		const actionsErrors  = actionsValidator.validate(schema.actions)
+		const actionsErrors = actionsValidator.validate(schema.actions)
 
 		const allErrors = [...aclErrors, ...modelErrors, ...validationErrors, ...actionsErrors]
 		if (skippedErrors.length === 0) {
 			return allErrors
 		}
 		return allErrors.filter(
-			err => !skippedErrors.some(
-				rule => err.code === rule.code
-					&& (!rule.path || err.path.join('.') === rule.path),
-			),
+			err =>
+				!skippedErrors.some(
+					rule =>
+						err.code === rule.code
+						&& (!rule.path || err.path.join('.') === rule.path),
+				),
 		)
 	}
 }

package/src/validation/ValidationValidator.ts

@@ -65,7 +65,6 @@ export class ValidationValidator {
 		this.validateValidator(errorBuilder.for('validator'), rule.validator, entity, field)
 	}
 
-
 	private validateValidator(
 		errorBuilder: ErrorBuilder,
 		validator: Validation.Validator,
@@ -120,7 +119,7 @@ export class ValidationValidator {
 				)
 				return
 			default:
-				((_: never) => {
+				;((_: never) => {
 					errorBuilder.for('operation', `Operation ${(validatorCast as any).operation} is not an valid option`)
 				})(validatorCast)
 		}
@@ -135,7 +134,6 @@ export class ValidationValidator {
 		this.validateValidator(errorBuilder.for('validator'), argument.validator, entity, field)
 	}
 
-
 	private validatePathArgument(
 		errorBuilder: ErrorBuilder,
 		argument: Validation.PathArgument,

package/src/validation/errors.ts

@@ -11,21 +11,18 @@ export type ValidationErrorCode =
 	| 'MODEL_INVALID_ENTITY_NAME'
 	| 'MODEL_INVALID_CONSTRAINT'
 	| 'MODEL_NAME_COLLISION'
-
 	| 'ACL_INVALID_CONDITION'
 	| 'ACL_UNDEFINED_VARIABLE'
 	| 'ACL_UNDEFINED_FIELD'
 	| 'ACL_UNDEFINED_PREDICATE'
 	| 'ACL_UNDEFINED_ROLE'
 	| 'ACL_UNDEFINED_ENTITY'
-
 	| 'ACTIONS_NAME_MISMATCH'
 	| 'ACTIONS_INVALID_CONDITION'
 	| 'ACTIONS_UNDEFINED_FIELD'
 	| 'ACTIONS_UNDEFINED_ENTITY'
 	| 'ACTIONS_UNDEFINED_TRIGGER_TARGET'
 	| 'ACTIONS_INVALID_SELECTION'
-
 	| 'VALIDATION_UNDEFINED_ENTITY'
 	| 'VALIDATION_UNDEFINED_FIELD'
 	| 'VALIDATION_NOT_IMPLEMENTED'

package/tests/cases/unit/conditionSchema.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'
 
@@ -31,7 +31,6 @@ describe('condition schema', () => {
 		expect(() => conditionSchema(Model.ColumnType.Int)(condition)).toThrow('value at root: extra property containsCI found')
 	})
 
-
 	test('accept non-json condition for unknown type', () => {
 		const condition = {
 			eq: 'foo',

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

@@ -1,4 +1,4 @@
-import { expect, describe, test } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 import { compareArraysIgnoreOrder } from '../../../src'
 
 describe('deep compare', () => {
@@ -38,7 +38,6 @@ describe('deep compare', () => {
 		expect(actual).toStrictEqual([{
 			path: [],
 			message: 'Array item: {"foo":"bar"} not found in [{"lorem":"ipsum"},{"lorem":"ipsum"}]',
-		}],
-		)
+		}])
 	})
 })

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

@@ -18,7 +18,6 @@ test('lax schema converter basic', () => {
 	expect(converter.convert()).toMatchSnapshot()
 })
 
-
 test('lax schema converter one-has-many', () => {
 	const converter = new LaxSchemaConverter(
 		{
@@ -57,7 +56,6 @@ test('lax schema converter one-has-many', () => {
 	expect(converter2.convert()).toStrictEqual(schema1)
 })
 
-
 test('lax schema converter many-has-many', () => {
 	const converter = new LaxSchemaConverter(
 		{
@@ -96,7 +94,6 @@ test('lax schema converter many-has-many', () => {
 	expect(converter2.convert()).toStrictEqual(schema1)
 })
 
-
 test('lax schema converter one-has-one', () => {
 	const converter = new LaxSchemaConverter(
 		{
@@ -134,4 +131,3 @@ test('lax schema converter one-has-one', () => {
 	)
 	expect(converter2.convert()).toStrictEqual(schema1)
 })
-

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

@@ -6,18 +6,23 @@ 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, false)
+		[
+			{ 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] } }] },
@@ -26,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, false)
+		[
+			{ role: 'editor', variables: [] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_EMPTY,
 		role: 'editor',
@@ -73,18 +83,23 @@ 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 },
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {
+						cond: { type: Acl.VariableType.condition },
+					},
+					entities: {},
 				},
-				entities: {},
 			},
 		},
-	}, [
-		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify({ eq: 'foo' })] }] },
-	], MembershipResolver.UnknownIdentity, false)
+		[
+			{ 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' } }] },
@@ -104,7 +119,8 @@ test('fails when trying to override predefined variable with stored', () => {
 		},
 	}, [
 		{
-			role: 'editor', variables: [
+			role: 'editor',
+			variables: [
 				{ name: 'self', values: [id2] },
 			],
 		},
@@ -121,7 +137,6 @@ test('fails when trying to override predefined variable with stored', () => {
 	])
 })
 
-
 test('read overridden predefined variable with assume', () => {
 	const reader = new MembershipResolver()
 	const result = reader.resolve({
@@ -135,7 +150,8 @@ test('read overridden predefined variable with assume', () => {
 		},
 	}, [
 		{
-			role: 'editor', variables: [
+			role: 'editor',
+			variables: [
 				{ name: 'self', values: [id2] },
 			],
 		},
@@ -148,21 +164,25 @@ test('read overridden predefined variable with assume', () => {
 	])
 })
 
-
 test('fails on invalid condition', () => {
 	const reader = new MembershipResolver()
-	const result = reader.resolve({
-		roles: {
-			editor: {
-				variables: {
-					cond: { type: Acl.VariableType.condition },
+	const result = reader.resolve(
+		{
+			roles: {
+				editor: {
+					variables: {
+						cond: { type: Acl.VariableType.condition },
+					},
+					entities: {},
 				},
-				entities: {},
 			},
 		},
-	}, [
-		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
-	], MembershipResolver.UnknownIdentity, false)
+		[
+			{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_INVALID,
@@ -178,8 +198,7 @@ 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')] }] },
 	], {
@@ -197,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, false)
+		[
+			{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
+		],
+		MembershipResolver.UnknownIdentity,
+		false,
+	)
 
 	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_NOT_FOUND,
@@ -219,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, false)
+		[
+			{ 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 {