@contember/schema-definition 2.1.0-alpha.3 → 2.1.0-alpha.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-definition",
-  "version": "2.1.0-alpha.3",
+  "version": "2.1.0-alpha.35",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -23,16 +23,21 @@
     }
   },
   "dependencies": {
-    "@contember/schema": "2.1.0-alpha.3",
-    "@contember/schema-utils": "2.1.0-alpha.3",
-    "reflect-metadata": "^0.2.2",
-    "fast-deep-equal": "^3.1.3"
+    "@contember/schema": "workspace:*",
+    "@contember/schema-utils": "workspace:*",
+    "reflect-metadata": "catalog:",
+    "fast-deep-equal": "catalog:"
   },
   "devDependencies": {
-    "graphql": "^16.9.0"
+    "graphql": "catalog:"
   },
   "peerDependencies": {
-    "graphql": ">= 14.6.0"
+    "graphql": "catalog:"
   },
-  "type": "module"
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/contember/contember.git",
+    "directory": "packages/schema-definition"
+  }
 }

package/src/acl/builder/EntityPermissionsBuilder.ts

@@ -121,7 +121,7 @@ export default class EntityPermissionsBuilder {
 				tuple(
 					it,
 					Object.values(it.fields).filter(field => fieldSelectorConst.matches(this.schema, it, field)),
-				),
+				)
 			)
 			.reduce<[Model.Entity, Model.AnyField][]>(
 				(acc, [entity, fields]) => [...acc, ...fields.map(it => tuple(entity, it))],

package/src/acl/builder/EntitySelector.ts

@@ -21,8 +21,8 @@ export default class EntitySelector {
 	public havingRelation(name: string, targetEntityName?: string) {
 		return this.matching(
 			(schema, entity) =>
-				entity.fields[name] &&
-				acceptFieldVisitor(schema, entity, name, {
+				entity.fields[name]
+				&& acceptFieldVisitor(schema, entity, name, {
 					visitColumn: () => false,
 					visitRelation: ({ targetEntity }) => !targetEntityName || targetEntity.name === targetEntityName,
 				}),

package/src/acl/builder/PermissionOverrider.ts

@@ -27,18 +27,20 @@ export default class PermissionOverrider {
 					? {}
 					: {
 						delete: overrides.operations.delete ?? original.operations.delete,
-					  }),
+					}),
 				...(original.operations.customPrimary === undefined && overrides.operations.customPrimary === undefined
 					? {}
 					: {
 						customPrimary: overrides.operations.customPrimary ?? original.operations.customPrimary,
-					  }),
-				...(original.operations.noRoot || overrides.operations.noRoot ? {
-					noRoot: [
-						...(original.operations.noRoot || []),
-						...(overrides.operations.noRoot || []),
-					],
-				} : {}),
+					}),
+				...(original.operations.noRoot || overrides.operations.noRoot
+					? {
+						noRoot: [
+							...(original.operations.noRoot || []),
+							...(overrides.operations.noRoot || []),
+						],
+					}
+					: {}),
 			},
 		}
 	}

package/src/acl/builder/PermissionsBuilder.ts

@@ -38,9 +38,7 @@ class PermissionsBuilder {
 			entitySelector = EntitySelector.named(...entitySelector)
 		}
 		const entitySelectorWithType = entitySelector
-		const entities = Object.values(this.schema.entities).filter(entity =>
-			entitySelectorWithType.matches(this.schema, entity),
-		)
+		const entities = Object.values(this.schema.entities).filter(entity => entitySelectorWithType.matches(this.schema, entity))
 		return new EntityPermissionsBuilder(this, entities)
 	}
 

package/src/acl/definition/aclExtensions.ts

@@ -2,19 +2,18 @@ import { Acl, Model } from '@contember/schema'
 import { createMetadataStore, DecoratorFunction, EntityConstructor } from '../../utils'
 import { Role } from './roles'
 
-export type EntityAclExtensionArgs =
-	& {
-		entity: Model.Entity
-		role: Role
-		permissions: Acl.EntityPermissions
-	}
+export type EntityAclExtensionArgs = {
+	entity: Model.Entity
+	role: Role
+	permissions: Acl.EntityPermissions
+}
 
 const entityAclExtensionsStore = createMetadataStore<EntityAclExtension[]>([])
 
 export type EntityAclExtension = (args: EntityAclExtensionArgs) => Acl.EntityPermissions
 export const extendEntityAcl = <T>(extension: EntityAclExtension): DecoratorFunction<T> => {
-	return function (cls: EntityConstructor) {
-		entityAclExtensionsStore.update(cls, current => [...current, extension])
+	return function(cls: EntityConstructor, context?: ClassDecoratorContext) {
+		entityAclExtensionsStore.update(cls, current => [...current, extension], context)
 	}
 }
 

package/src/acl/definition/customPrimary.ts

@@ -5,7 +5,7 @@ import { extendEntityAcl } from './aclExtensions'
 export const allowCustomPrimary = (role?: Role | Role[]): DecoratorFunction<any> => {
 	return extendEntityAcl(({ permissions, role: currentRole }) => {
 		if (!role || role === currentRole || (Array.isArray(role) && role.includes(currentRole))) {
-			return { ...permissions, operations: { customPrimary: true } }
+			return { ...permissions, operations: { ...permissions.operations, customPrimary: true } }
 		}
 		return permissions
 	})

package/src/acl/definition/internal/AclFactory.ts

@@ -3,12 +3,9 @@ import { getEntity } from '@contember/schema-utils'
 
 import { EntityPredicatesResolver } from './EntityPredicateResolver'
 import { AllowDefinition } from '../permissions'
-import {
-	allowDefinitionsStore,
-	EntityPermissionsDefinition,
-} from './stores'
+import { allowDefinitionsStore, EntityPermissionsDefinition } from './stores'
 import { Role } from '../roles'
-import {  VariableDefinition } from '../variables'
+import { VariableDefinition } from '../variables'
 import { filterEntityDefinition } from '../../../utils'
 import { applyEntityAclExtensions } from '../aclExtensions'
 
@@ -25,7 +22,7 @@ export class AclFactory {
 		const roles: Role[] = Object.values(exportedDefinitions).filter(it => it instanceof Role)
 		const variables: VariableDefinition[] = Object.values(exportedDefinitions).filter(it => it instanceof VariableDefinition)
 
-		const groupedPermissions = AclFactory.groupPermissions(entityLikeDefinition, roles)
+		const groupedPermissions = this.groupPermissions(entityLikeDefinition, roles)
 
 		return {
 			roles: Object.fromEntries(roles.map((role): [string, Acl.RolePermissions] => {
@@ -43,19 +40,25 @@ export class AclFactory {
 		}
 	}
 
-	private createPermissions(rolePermissions: PermissionsByEntity | undefined, entityLikeDefinition: Record<string, { new(): any }>, role: Role): Acl.Permissions {
-		return Object.fromEntries(Object.values(this.model.entities).map((entity): [string, Acl.EntityPermissions] | undefined => {
-			const permissions = rolePermissions ? this.createPermissionsFromAllow(rolePermissions, entity) : { predicates: {}, operations: {} }
-			const isEmpty = rolePermissions === undefined
-			const withExtensions = applyEntityAclExtensions(entityLikeDefinition[entity.name], { entity, permissions, role })
-			if (isEmpty && withExtensions === permissions) {
-				return undefined
-			}
-			return [
-				entity.name,
-				withExtensions,
-			]
-		}).filter(<T>(it: T | undefined): it is T => it !== undefined))
+	private createPermissions(
+		rolePermissions: PermissionsByEntity | undefined,
+		entityLikeDefinition: Record<string, { new(): any }>,
+		role: Role,
+	): Acl.Permissions {
+		return Object.fromEntries(
+			Object.values(this.model.entities).map((entity): [string, Acl.EntityPermissions] | undefined => {
+				const permissions = rolePermissions ? this.createPermissionsFromAllow(rolePermissions, entity) : { predicates: {}, operations: {} }
+				const isEmpty = !rolePermissions?.has(entity.name)
+				const withExtensions = applyEntityAclExtensions(entityLikeDefinition[entity.name], { entity, permissions, role })
+				if (isEmpty && withExtensions === permissions) {
+					return undefined
+				}
+				return [
+					entity.name,
+					withExtensions,
+				]
+			}).filter(<T>(it: T | undefined): it is T => it !== undefined),
+		)
 	}
 
 	private createPermissionsFromAllow(rolePermissions: PermissionsByEntity, entity: Model.Entity): Acl.EntityPermissions {
@@ -88,7 +91,6 @@ export class AclFactory {
 		}
 	}
 
-
 	getNoRootOptions(entity: Model.Entity, permissions?: EntityPermissions): Acl.EntityOperations['noRoot'] {
 		const allowedRoot = new Set<Acl.Operation>()
 		const disallowedRoot = new Set<Acl.Operation>()
@@ -106,7 +108,6 @@ export class AclFactory {
 					}
 				}
 			}
-
 		}
 		return [...disallowedRoot.values()]
 	}
@@ -118,7 +119,7 @@ export class AclFactory {
 		}))
 	}
 
-	private static groupPermissions(entityLikeDefinition: [string, { new(): any }][], roles: Role[]): PermissionsByRoleAndEntity {
+	private groupPermissions(entityLikeDefinition: [string, { new(): any }][], roles: Role[]): PermissionsByRoleAndEntity {
 		const groupedPermissions: PermissionsByRoleAndEntity = new Map()
 		for (const [name, entity] of entityLikeDefinition) {
 			const initEntityPermissions = (role: Role): EntityPermissions => {
@@ -131,12 +132,17 @@ export class AclFactory {
 				return entityPermissions
 			}
 			const metadata: EntityPermissionsDefinition[] = allowDefinitionsStore.get(entity)
-			for (const { role, ...definition } of metadata) {
+			for (const { role, factory } of metadata) {
 				if (!roles.includes(role)) {
 					throw `Role ${role.name} used on entity ${name} is not registered. Have you exported it?`
 				}
 				const entityPermissions = initEntityPermissions(role)
-				entityPermissions.definitions.push(definition)
+				const entity = getEntity(this.model, name)
+				entityPermissions.definitions.push(factory({
+					model: this.model,
+					entity: getEntity(this.model, name),
+					except: (...fields) => (Object.keys(entity.fields)).filter(it => !fields.includes(it)),
+				}))
 			}
 		}
 
@@ -144,7 +150,6 @@ export class AclFactory {
 	}
 }
 
-
 export type EntityPermissions = { definitions: AllowDefinition<any>[] }
 export type PermissionsByEntity = Map<string, EntityPermissions>
 export type PermissionsByRoleAndEntity = Map<Role, PermissionsByEntity>

package/src/acl/definition/internal/EntityPredicateResolver.ts

@@ -80,7 +80,6 @@ export class EntityPredicatesResolver {
 			return predicateNames[0]
 		}
 
-
 		const predicate = { or: predicateNames.map(it => this.predicates[it]) }
 		const origName = predicateNames.every(it => this.generatedNames.has(it)) ? createPredicateName(predicate) : predicateNames.join('_or_')
 		let predicateName = origName
@@ -102,7 +101,6 @@ export class EntityPredicatesResolver {
 		return Object.fromEntries(Object.entries(this.predicates).filter(([name]) => this.usedPredicates.includes(name)))
 	}
 
-
 	private static resolvePredicate(
 		model: Model.Schema,
 		entity: Model.Entity,
@@ -116,7 +114,9 @@ export class EntityPredicatesResolver {
 					return ctx.value.name
 				}
 				if (ctx.value instanceof PredicateEvaluationReference) {
-					throw `Predicate references are allowed only on relations. \nYou cannot use "can${upperCaseFirst(ctx.value.operation)}(${ctx.value.field ? JSON.stringify(ctx.value.field) : ''})" on a column "${ctx.column.name}" of entity "${ctx.entity.name}".`
+					throw `Predicate references are allowed only on relations. \nYou cannot use "can${upperCaseFirst(ctx.value.operation)}(${
+						ctx.value.field ? JSON.stringify(ctx.value.field) : ''
+					})" on a column "${ctx.column.name}" of entity "${ctx.entity.name}".`
 				}
 				return ctx.value
 			},
@@ -138,7 +138,7 @@ export class EntityPredicatesResolver {
 						return { [ctx.targetEntity.primary]: { isNull: false } }
 					}
 					const predicates = (whens as WhenDefinition[]).map(it =>
-						EntityPredicatesResolver.resolvePredicate(model, ctx.targetEntity, it, rolePermissionsByEntity),
+						EntityPredicatesResolver.resolvePredicate(model, ctx.targetEntity, it, rolePermissionsByEntity)
 					)
 					if (predicates.length > 1) {
 						return { or: predicates }

package/src/acl/definition/internal/stores.ts

@@ -1,10 +1,9 @@
 import { createMetadataStore } from '../../../utils/MetadataStore'
+import { AllowDefinitionFactory } from '../permissions'
 import { Role } from '../roles'
-import { AllowDefinition } from '../permissions'
 
-export type EntityPermissionsDefinition =
-	& AllowDefinition<any>
-	& {
-		role: Role<string>
-	}
+export type EntityPermissionsDefinition = {
+	factory: AllowDefinitionFactory<any>
+	role: Role<string>
+}
 export const allowDefinitionsStore = createMetadataStore<EntityPermissionsDefinition[]>([])

package/src/acl/definition/permissions.ts

@@ -1,4 +1,4 @@
-import { Acl } from '@contember/schema'
+import { Acl, Model } from '@contember/schema'
 import { Role } from './roles'
 import { VariableDefinition } from './variables'
 import { PredicateEvaluationReference } from './references'
@@ -18,13 +18,19 @@ export interface AllowDefinition<E> {
 	delete?: true
 }
 
-export const allow = <E, R extends Role<string>>(role: R | R[], args: AllowDefinition<E>): DecoratorFunction<E> => {
-	return (entity: EntityConstructor<E>) => {
-		(Array.isArray(role) ? role : [role]).forEach(role => {
-			allowDefinitionsStore.update(entity, val => [...val, { ...args, role }])
+export type AllowDefinitionFactory<E> = (args: {
+	model: Model.Schema
+	entity: Model.Entity<(keyof E) & string>
+	except: (...fields: (keyof E)[]) => (keyof E)[]
+}) => AllowDefinition<E>
+
+export const allow = <E, R extends Role<string>>(role: R | R[], args: AllowDefinition<E> | AllowDefinitionFactory<E>): DecoratorFunction<E> => {
+	return (entity: EntityConstructor<E>, context?: ClassDecoratorContext) => {
+		;(Array.isArray(role) ? role : [role]).forEach(role => {
+			allowDefinitionsStore.update(entity, val => [...val, {
+				factory: typeof args === 'function' ? args : () => args,
+				role,
+			}], context)
 		})
 	}
 }
-
-
-

package/src/acl/definition/variables.ts

@@ -1,7 +1,11 @@
 import { Role } from './roles'
 import { Acl, Input } from '@contember/schema'
 
-export class VariableDefinition<Name extends string = string, Roles extends Role<string> = Role<string>, Variable extends Acl.Variable = Acl.Variable> {
+export class VariableDefinition<
+	Name extends string = string,
+	Roles extends Role<string> = Role<string>,
+	Variable extends Acl.Variable = Acl.Variable,
+> {
 	constructor(
 		public readonly name: Name,
 		public readonly roles: Roles[],

package/src/actions/definition/index.ts

@@ -4,7 +4,6 @@ import { ActionsFactory } from './internal/ActionsFactory'
 export * from './triggers'
 export * from './targets'
 
-
 export const createActions = (
 	exportedDefinitions: Record<string, any>,
 ): Actions.Schema => {

package/src/actions/definition/internal/ActionsFactory.ts

@@ -6,10 +6,6 @@ import { ActionsTarget } from '../targets'
 import { Kind, parse, SelectionNode, ValueNode } from 'graphql'
 
 export class ActionsFactory {
-	constructor(
-	) {
-	}
-
 	public create(
 		exportedDefinitions: Record<string, any>,
 	): Actions.Schema {
@@ -24,10 +20,12 @@ export class ActionsFactory {
 			targetsRegistry.register(name, def.definition)
 		}
 
-		const triggersDef = entityLikeDefinition.flatMap(([, entity]) => triggersStore.get(entity).map(it => ({
-			...it,
-			entity,
-		})))
+		const triggersDef = entityLikeDefinition.flatMap(([, entity]) =>
+			triggersStore.get(entity).map(it => ({
+				...it,
+				entity,
+			}))
+		)
 
 		const triggerNames = triggersDef.map(it => it.definition.name).filter((it): it is string => !!it)
 		triggerNames.forEach((it, index, arr) => {
@@ -57,7 +55,6 @@ export class ActionsFactory {
 			triggers[name] = trigger
 		}
 
-
 		return { triggers, targets: targetsRegistry.getTargets() }
 	}
 
@@ -101,6 +98,7 @@ export class ActionsFactory {
 			watch: this.parseSelection(trigger.watch),
 			selection: trigger.selection ? this.parseSelection(trigger.selection) : undefined,
 			priority: trigger.priority,
+			...('withNodes' in trigger ? { withNodes: trigger.withNodes } : {}),
 		}
 	}
 

package/src/actions/definition/targets.ts

@@ -1,6 +1,5 @@
 import { Actions } from '@contember/schema'
 
-
 export class ActionsTarget {
 	constructor(
 		public readonly name: string | undefined,

package/src/actions/definition/triggers.ts

@@ -35,15 +35,17 @@ export type BasicTriggerDefinition =
 export type WatchTriggerDefinition =
 	& {
 		readonly watch: Actions.SelectionNode | string
+		readonly withNodes?: boolean
 	}
 	& CommonTriggerDefinition
 	& TargetDefinition
 
-export const trigger = <T>(definition: BasicTriggerDefinition): DecoratorFunction<T> => (entity: EntityConstructor<T>) => {
-	triggersStore.update(entity, it => [...it, { type: 'basic', definition }])
-}
-
-export const watch = <T>(definition: WatchTriggerDefinition): DecoratorFunction<T> => (entity: EntityConstructor<T>) => {
-	triggersStore.update(entity, it => [...it, { type: 'watch', definition }])
-}
+export const trigger =
+	<T>(definition: BasicTriggerDefinition): DecoratorFunction<T> => (entity: EntityConstructor<T>, context?: ClassDecoratorContext) => {
+		triggersStore.update(entity, it => [...it, { type: 'basic', definition }], context)
+	}
 
+export const watch =
+	<T>(definition: WatchTriggerDefinition): DecoratorFunction<T> => (entity: EntityConstructor<T>, context?: ClassDecoratorContext) => {
+		triggersStore.update(entity, it => [...it, { type: 'watch', definition }], context)
+	}

package/src/createSchema.ts

@@ -4,7 +4,7 @@ import * as AclDefinition from './acl/definition'
 import * as ActionsDefinition from './actions/definition'
 import { Model, Schema } from '@contember/schema'
 import { emptySchema } from '@contember/schema-utils'
-import { allStrict, StrictOptions, StrictDefinitionValidator } from './strict'
+import { allStrict, StrictDefinitionValidator, StrictOptions } from './strict'
 
 export const createSchema = (definitions: Record<string, any>, modifyCallback?: (schema: Schema) => Schema, options?: {
 	strict?: boolean | StrictOptions

package/src/index.ts

@@ -14,20 +14,19 @@ export type { Role }
 export type { VariableDefinition } from './acl/definition'
 export type {
 	ColumnDefinition,
+	EnumDefinition,
 	FieldDefinition,
-	OneHasOneDefinition,
-	OneHasOneInverseDefinition,
-	OneHasManyDefinition,
-	ManyHasOneDefinition,
 	ManyHasManyDefinition,
 	ManyHasManyInverseDefinition,
-	EnumDefinition,
+	ManyHasOneDefinition,
+	OneHasManyDefinition,
+	OneHasOneDefinition,
+	OneHasOneInverseDefinition,
 } from './model/definition'
 
-export { AclDefinition, ActionsDefinition, SchemaDefinition, InputValidation, createSchema }
+export { AclDefinition, ActionsDefinition, createSchema, InputValidation, SchemaDefinition }
 
 export const c = {
-
 	// ACL
 	// ACL entity decorators
 	AllowCustomPrimary: AclDefinition.allowCustomPrimary,
@@ -43,7 +42,6 @@ export const c = {
 	canUpdate: AclDefinition.canUpdate,
 	canDelete: AclDefinition.canDelete,
 
-
 	// Actions
 	// Actions entity decorators
 	Watch: ActionsDefinition.watch,
@@ -51,7 +49,6 @@ export const c = {
 	// Actions factories
 	createActionsTarget: ActionsDefinition.createTarget,
 
-
 	// Model
 	// Model entity decorators
 	ExtendEntity: SchemaDefinition.extendEntity,
@@ -81,7 +78,6 @@ export const c = {
 	// Model factories
 	createEnum: SchemaDefinition.createEnum,
 
-
 	// Validation
 	// Validation field decorators
 	Assert: InputValidation.assert,
@@ -94,5 +90,4 @@ export const c = {
 	ValidateWhen: InputValidation.when,
 	// Validation utilities
 	rules: InputValidation.rules,
-
 }

package/src/model/builder/ColumnBuilder.ts

@@ -16,11 +16,13 @@ class ColumnBuilder<O extends PartialColumnOptions<never> = PartialColumnOptions
 		type: Model.ColumnType,
 		typeOptions: ColumnBuilder.TypeOptions = {},
 	): ColumnBuilder<O & PartialColumnOptions<'type'>> {
-		return new ColumnBuilder<O & PartialColumnOptions<'type'>>({
-			...(this.options as object),
-			type: type,
-			...typeOptions,
-		} as O & PartialColumnOptions<'type'>)
+		return new ColumnBuilder<O & PartialColumnOptions<'type'>>(
+			{
+				...(this.options as object),
+				type: type,
+				...typeOptions,
+			} as O & PartialColumnOptions<'type'>,
+		)
 	}
 
 	public nullable(): ColumnBuilder<O> {

package/src/model/builder/internal/ColumnProcessor.ts

@@ -27,7 +27,6 @@ export default class ColumnProcessor implements FieldProcessor<ColumnBuilder.Opt
 			nullable: options.nullable === undefined ? true : options.nullable,
 		}
 		if (type === Model.ColumnType.Enum) {
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 			return { ...common, type: type, columnType: options.enumName! }
 		}
 		return {

package/src/model/definition/IndexDefinition.ts

@@ -1,17 +1,21 @@
 import { extendEntity } from './extensions'
 import { DecoratorFunction } from '../../utils'
+import { Model } from '@contember/schema'
 
-export type IndexOptions<T> = { fields: (keyof T)[] }
+export type IndexOptions<T> = {
+	fields: (keyof T)[]
+	method?: Model.IndexMethod
+}
 export function Index<T>(options: IndexOptions<T>): DecoratorFunction<T>
 export function Index<T>(...fields: (keyof T)[]): DecoratorFunction<T>
 export function Index<T>(options: IndexOptions<T> | keyof T, ...args: (keyof T)[]): DecoratorFunction<T> {
 	return extendEntity(({ entity }) => {
-		const fields = (typeof options !== 'object' ? [options, ...args] : options.fields) as string[]
+		const indexDef = (typeof options !== 'object' ? { fields: [options, ...args] } : options) as { fields: string[]; method?: Model.IndexMethod }
 		return {
 			...entity,
 			indexes: [
 				...entity.indexes,
-				{ fields },
+				indexDef,
 			],
 		}
 	})

package/src/model/definition/OrderByDefinition.ts

@@ -2,15 +2,16 @@ import { Model } from '@contember/schema'
 import { extendEntity } from './extensions'
 import { DecoratorFunction } from '../../utils'
 
-
 export type OrderByDirection = Model.OrderDirection | `${Model.OrderDirection}`
 export type OrderByOptions = { path: string[]; direction?: OrderByDirection }
 
-
 export function OrderBy<T>(options: OrderByOptions): DecoratorFunction<T>
 export function OrderBy<T>(options: OrderByOptions[]): DecoratorFunction<T>
 export function OrderBy<T>(path: (keyof T) & string, direction?: OrderByDirection): DecoratorFunction<T>
-export function OrderBy<T>(options: OrderByOptions | OrderByOptions[] | ((keyof T) & string), direction?: `${Model.OrderDirection}`): DecoratorFunction<T> {
+export function OrderBy<T>(
+	options: OrderByOptions | OrderByOptions[] | ((keyof T) & string),
+	direction?: `${Model.OrderDirection}`,
+): DecoratorFunction<T> {
 	return extendEntity(({ entity }) => {
 		const normalize = (path: string[], direction?: OrderByDirection): Model.OrderBy => ({
 			path,
@@ -27,8 +28,9 @@ export function OrderBy<T>(options: OrderByOptions | OrderByOptions[] | ((keyof
 		})()
 
 		if (entity.orderBy?.length) {
-			// eslint-disable-next-line no-console
-			console.warn(`DEPRECATED: The "order by" property for the entity ${entity.name} has already been defined. Using multiple decorators can lead to unexpected order. Please provide an array containing all the 'order by' items as an input.`)
+			console.warn(
+				`DEPRECATED: The "order by" property for the entity ${entity.name} has already been defined. Using multiple decorators can lead to unexpected order. Please provide an array containing all the 'order by' items as an input.`,
+			)
 		}
 
 		return {

package/src/model/definition/UniqueDefinition.ts

@@ -2,19 +2,21 @@ import { extendEntity } from './extensions'
 import { DecoratorFunction } from '../../utils'
 import { Model } from '@contember/schema'
 
-export type UniqueOptions<T> = {
-	fields: (keyof T & string)[]
-
-} & (
-	| {
-		index?: false
-		timing?: Model.ConstraintTiming
-	}
-	| {
-		index: true
-		nulls?: Model.NullsDistinctBehaviour
+export type UniqueOptions<T> =
+	& {
+		fields: (keyof T & string)[]
 	}
-)
+	& (
+		| {
+			index?: false
+			timing?: Model.ConstraintTiming
+		}
+		| {
+			index: true
+			nulls?: Model.NullsDistinctBehaviour
+			method?: Model.IndexMethod
+		}
+	)
 export function Unique<T>(options: UniqueOptions<T>): DecoratorFunction<T>
 export function Unique<T>(...fields: (keyof T & string)[]): DecoratorFunction<T>
 export function Unique<T>(options: UniqueOptions<T> | keyof T & string, ...args: (keyof T & string)[]): DecoratorFunction<T> {

package/src/model/definition/extensions.ts

@@ -17,8 +17,8 @@ const entityExtensionsStore = createMetadataStore<EntityExtension[]>([])
 
 export type EntityExtension = (args: EntityExtensionArgs) => Model.Entity
 export const extendEntity = <T>(extension: EntityExtension): DecoratorFunction<T> => {
-	return function (cls: EntityConstructor) {
-		entityExtensionsStore.update(cls, current => [...current, extension])
+	return function(cls: EntityConstructor, context?: ClassDecoratorContext) {
+		entityExtensionsStore.update(cls, current => [...current, extension], context)
 	}
 }