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

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)
 	}
 }
 

package/src/model/definition/fieldDefinitions/ColumnDefinition.ts

@@ -6,7 +6,6 @@ import { resolveDefaultColumnType } from '@contember/schema-utils'
 export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 	type = 'ColumnDefinition' as const
 
-
 	public static create(
 		type: Model.ColumnType,
 		typeOptions: ColumnTypeOptions = {},
@@ -17,7 +16,6 @@ export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 		})
 	}
 
-
 	public columnName(columnName: string): ColumnDefinition {
 		return this.withOption('columnName', columnName)
 	}
@@ -62,7 +60,18 @@ export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 	}
 
 	createField({ name, conventions, enumRegistry, entityName, options }: CreateFieldContext): Model.AnyField {
-		const { type, nullable, columnName, enumDefinition, default: defaultValue, columnType, typeAlias, sequence, list, collation = options.defaultCollation } = this.options
+		const {
+			type,
+			nullable,
+			columnName,
+			enumDefinition,
+			default: defaultValue,
+			columnType,
+			typeAlias,
+			sequence,
+			list,
+			collation = options.defaultCollation,
+		} = this.options
 		const common = {
 			name: name,
 			columnName: columnName || conventions.getColumnName(name),
@@ -165,4 +174,3 @@ export type ColumnDefinitionOptions = {
 	sequence?: Model.ColumnTypeDefinition['sequence']
 	collation?: Model.Collation
 } & ColumnTypeOptions
-

package/src/model/definition/fieldDefinitions/FieldDefinition.ts

@@ -8,7 +8,7 @@ export abstract class FieldDefinition<O> {
 }
 
 export type CreateFieldContext =
-	&  {
+	& {
 		name: string
 		entityName: string
 	}

package/src/model/definition/fieldDefinitions/ManyHasManyDefinition.ts

@@ -49,13 +49,11 @@ export class ManyHasManyDefinition extends FieldDefinition<ManyHasManyDefinition
 		}
 	}
 
-
 	protected withOption<K extends keyof ManyHasManyDefinitionOptions>(key: K, value: ManyHasManyDefinitionOptions[K]): ManyHasManyDefinition {
 		return new ManyHasManyDefinition({ ...this.options, [key]: value })
 	}
 }
 
-
 export function manyHasMany(target: EntityConstructor, inversedBy?: string): ManyHasManyDefinition {
 	return new ManyHasManyDefinition({ target, inversedBy })
 }

package/src/model/definition/fieldDefinitions/ManyHasManyInverseDefinition.ts

@@ -24,12 +24,14 @@ export class ManyHasManyInverseDefinition extends FieldDefinition<ManyHasManyInv
 		}
 	}
 
-	protected withOption<K extends keyof ManyHasManyInverseDefinitionOptions>(key: K, value: ManyHasManyInverseDefinitionOptions[K]): ManyHasManyInverseDefinition {
+	protected withOption<K extends keyof ManyHasManyInverseDefinitionOptions>(
+		key: K,
+		value: ManyHasManyInverseDefinitionOptions[K],
+	): ManyHasManyInverseDefinition {
 		return new ManyHasManyInverseDefinition({ ...this.options, [key]: value })
 	}
 }
 
-
 export function manyHasManyInverse(target: EntityConstructor, ownedBy: string): ManyHasManyInverseDefinition {
 	return new ManyHasManyInverseDefinition({ target, ownedBy })
 }

package/src/model/definition/fieldDefinitions/ManyHasOneDefinition.ts

@@ -1,4 +1,4 @@
-import { EntityConstructor,  RelationTarget } from '../types'
+import { EntityConstructor, RelationTarget } from '../types'
 import { Model } from '@contember/schema'
 import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
 

package/src/model/definition/fieldDefinitions/OneHasManyDefinition.ts

@@ -28,7 +28,6 @@ export class OneHasManyDefinition extends FieldDefinition<OneHasManyDefinitionOp
 	}
 }
 
-
 export function oneHasMany(target: EntityConstructor, ownedBy: string): OneHasManyDefinition {
 	return new OneHasManyDefinition({ target, ownedBy })
 }

package/src/model/definition/fieldDefinitions/OneHasOneDefinition.ts

@@ -5,7 +5,6 @@ import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
 export class OneHasOneDefinition extends FieldDefinition<OneHasOneDefinitionOptions> {
 	type = 'OneHasOneDefinition' as const
 
-
 	inversedBy(inversedBy: string): OneHasOneDefinition {
 		return this.withOption('inversedBy', inversedBy)
 	}
@@ -64,7 +63,6 @@ export class OneHasOneDefinition extends FieldDefinition<OneHasOneDefinitionOpti
 	}
 }
 
-
 export function oneHasOne(target: EntityConstructor, inversedBy?: string): OneHasOneDefinition {
 	return new OneHasOneDefinition({ target, inversedBy })
 }

package/src/model/definition/fieldDefinitions/OneHasOneInverseDefinition.ts

@@ -21,17 +21,19 @@ export class OneHasOneInverseDefinition extends FieldDefinition<OneHasOneInverse
 		}
 	}
 
-	protected withOption<K extends keyof OneHasOneInverseDefinitionOptions>(this: any, key: K, value: OneHasOneInverseDefinitionOptions[K]): OneHasOneInverseDefinition {
+	protected withOption<K extends keyof OneHasOneInverseDefinitionOptions>(
+		this: any,
+		key: K,
+		value: OneHasOneInverseDefinitionOptions[K],
+	): OneHasOneInverseDefinition {
 		return new this.constructor({ ...this.options, [key]: value })
 	}
 }
 
-
 export function oneHasOneInverse(target: EntityConstructor, ownedBy: string): OneHasOneInverseDefinition {
 	return new OneHasOneInverseDefinition({ target, ownedBy })
 }
 
-
 export type OneHasOneInverseDefinitionOptions = {
 	target: RelationTarget
 	ownedBy: string

package/src/model/definition/index.ts

@@ -5,7 +5,7 @@ import 'reflect-metadata'
 import { FieldDefinition } from './fieldDefinitions'
 import { isEntityConstructor } from '../../utils'
 import { DefaultNamingConventions } from '@contember/schema-utils'
-import { StrictOptions, StrictDefinitionValidator } from '../../strict'
+import { StrictDefinitionValidator, StrictOptions } from '../../strict'
 
 export * from './fieldDefinitions'
 export * from './EventLogDefinition'
@@ -14,7 +14,7 @@ export * from './OrderByDefinition'
 export * from './EnumDefinition'
 export * from './UniqueDefinition'
 export * from './ViewDefinition'
-export { extendEntity, type EntityExtension } from './extensions'
+export { type EntityExtension, extendEntity } from './extensions'
 
 export abstract class Entity {
 	[key: string]: FieldDefinition<any> | undefined

package/src/model/definition/internal/SchemaBuilder.ts

@@ -8,7 +8,7 @@ import { EntityRegistry } from './EntityRegistry'
 import { EnumRegistry } from './EnumRegistry'
 import { ColumnDefinition } from '../fieldDefinitions'
 import { applyEntityExtensions } from '../extensions'
-import { StrictOptions, StrictDefinitionValidator } from '../../../strict'
+import { StrictDefinitionValidator, StrictOptions } from '../../../strict'
 
 export class SchemaBuilder {
 	private entityRegistry = new EntityRegistry()
@@ -65,7 +65,6 @@ export class SchemaBuilder {
 					return { ...acc, [field.name]: field }
 				}, {})
 
-
 			const entity: Model.Entity = {
 				name: entityName,
 				primary: primaryName,

package/src/model/definition/types.ts

@@ -3,4 +3,4 @@ import { FieldDefinition } from './fieldDefinitions'
 
 export type RelationTarget = EntityConstructor
 export type FieldsDefinition = Record<string, FieldDefinition<any>>
-export { type EntityConstructor }
+export type { EntityConstructor }

package/src/model/index.ts

@@ -7,13 +7,4 @@ import OneHasOneBuilder from './builder/OneHasOneBuilder'
 import FieldBuilder from './builder/FieldBuilder'
 import * as SchemaDefinition from './definition'
 
-export {
-	SchemaBuilder,
-	ColumnBuilder,
-	ManyHasManyBuilder,
-	OneHasManyBuilder,
-	ManyHasOneBuilder,
-	OneHasOneBuilder,
-	FieldBuilder,
-	SchemaDefinition,
-}
+export { ColumnBuilder, FieldBuilder, ManyHasManyBuilder, ManyHasOneBuilder, OneHasManyBuilder, OneHasOneBuilder, SchemaBuilder, SchemaDefinition }

package/src/presets.ts

@@ -7,7 +7,6 @@ const v1_3preset: Settings.Schema = {
 	},
 }
 
-
 const v1_4preset: Settings.Schema = {
 	tenant: {
 		inviteExpirationMinutes: 60 * 24 * 7, // 7 days
@@ -29,7 +28,6 @@ const v2_0preset: Settings.Schema = {
 	},
 }
 
-
 const v2_1preset: Settings.Schema = {
 	...v2_0preset,
 	content: {

package/src/strict.ts

@@ -10,7 +10,6 @@ export const allStrict: StrictOptions = {
 	requireInverseSide: true,
 }
 
-
 export type Warning = { message: string }
 
 export class StrictDefinitionValidator {
@@ -27,10 +26,11 @@ export class StrictDefinitionValidator {
 		}
 	}
 
-
-	public validateOnCascade(entityName: string, field: string, definition: { onDelete?: Model.OnDelete}): void {
+	public validateOnCascade(entityName: string, field: string, definition: { onDelete?: Model.OnDelete }): void {
 		if (!definition.onDelete && this.options.requireOnDelete) {
-			this.registerWarning(`${entityName}.${field}: onDelete behaviour is not set. Use one of cascadeOnDelete(), setNullOnDelete() or restrictOnDelete().`)
+			this.registerWarning(
+				`${entityName}.${field}: onDelete behaviour is not set. Use one of cascadeOnDelete(), setNullOnDelete() or restrictOnDelete().`,
+			)
 		}
 	}
 

package/src/utils/MetadataStore.ts

@@ -2,22 +2,36 @@ import 'reflect-metadata'
 
 export interface MetadataStore<V> {
 	get(target: Object): V
-	update(target: Object, generator: (current: V) => V): void
+	update(target: Object, generator: (current: V) => V, context?: ClassDecoratorContext): void
+}
+
+const getTC39ClassMetadata = (target: Object, key: symbol): unknown => {
+	const metaSymbol: symbol | undefined = Symbol.metadata
+		?? Reflect.ownKeys(target).find((k): k is symbol => typeof k === 'symbol' && String(k) === 'Symbol(Symbol.metadata)')
+	if (!metaSymbol) return undefined
+	return (target as any)[metaSymbol]?.[key]
 }
 
 export const createMetadataStore = <V>(initialValue: V): MetadataStore<V> => {
 	const key = Symbol()
 	const get = (target: Object): V => {
-		return Reflect.hasMetadata(key, target)
+		const tc39 = getTC39ClassMetadata(target, key)
+		if (tc39 !== undefined) return tc39 as V
+		return typeof Reflect.hasMetadata === 'function' && Reflect.hasMetadata(key, target)
 			? Reflect.getMetadata(key, target)
 			: initialValue
 	}
 	return {
 		get,
-		update: (target, generator) => {
+		update: (target, generator, context?) => {
 			const current = get(target)
 			const newMetadata = generator(current)
-			Reflect.defineMetadata(key, newMetadata, target)
+			if (typeof Reflect.defineMetadata === 'function') {
+				Reflect.defineMetadata(key, newMetadata, target)
+			}
+			if (context) {
+				context.metadata[key] = newMetadata
+			}
 		},
 	}
 }

package/src/utils/decorators.ts

@@ -1,2 +1,2 @@
 export type EntityConstructor<T = any> = { new(): T }
-export type DecoratorFunction<T> = (cls: EntityConstructor<T>) => void
+export type DecoratorFunction<T> = (cls: EntityConstructor<T>, context?: ClassDecoratorContext) => void

package/src/utils/filterEntityDefinition.ts

@@ -1,7 +1,8 @@
 import { EntityConstructor } from './decorators'
 
-export const filterEntityDefinition = (definitions: Record<string, unknown>): [string, EntityConstructor][] => Object.entries(definitions)
-	.filter((it): it is [string, EntityConstructor] => isEntityConstructor(it[1]))
+export const filterEntityDefinition = (definitions: Record<string, unknown>): [string, EntityConstructor][] =>
+	Object.entries(definitions)
+		.filter((it): it is [string, EntityConstructor] => isEntityConstructor(it[1]))
 
 export const isEntityConstructor = (it: unknown): it is EntityConstructor => {
 	return typeof it === 'function' && 'constructor' in it && 'prototype' in it

package/src/validation/index.ts

@@ -1,6 +1,5 @@
 import { tuple } from '../utils'
 import { SchemaDefinition } from '../model'
-import 'reflect-metadata'
 import { Validation } from '@contember/schema'
 import { filterEntityDefinition } from '../utils'
 
@@ -31,21 +30,31 @@ const ArgumentFactory = {
 
 const RuleMetaKey = Symbol('Rule')
 
-function updateMetadata<T>(
-	{ key, target, propertyKey }: { key: symbol; target: any; propertyKey: string | symbol },
-	generator: (previous: T) => T,
-	initialValue: T,
-) {
-	const metadata = Reflect.hasMetadata(key, target, propertyKey)
-		? Reflect.getMetadata(key, target, propertyKey)
-		: initialValue
-
-	const newMetadata = generator(metadata)
-	Reflect.defineMetadata(key, newMetadata, target, propertyKey)
+const isLegacyDecorator = (target: any): boolean => typeof target === 'object' && target !== null || typeof target === 'function'
+
+function addRuleToMetadata(target: any, propertyKeyOrContext: any, ...rule: Validation.ValidationRule[]) {
+	if (isLegacyDecorator(target)) {
+		// Legacy TypeScript decorators: target is prototype, propertyKeyOrContext is property name
+		const propertyKey: string | symbol = propertyKeyOrContext
+		const hasExisting = Reflect.hasMetadata(RuleMetaKey, target, propertyKey)
+		const existing: Validation.ValidationRule[] = hasExisting ? Reflect.getMetadata(RuleMetaKey, target, propertyKey) : []
+		Reflect.defineMetadata(RuleMetaKey, [...rule, ...existing], target, propertyKey)
+	} else {
+		// TC39 stage 3 decorators: target is undefined, propertyKeyOrContext is context
+		const context = propertyKeyOrContext as ClassFieldDecoratorContext
+		const name = String(context.name)
+		const allRules = (context.metadata[RuleMetaKey] as Record<string, Validation.ValidationRule[]>) ?? {}
+		allRules[name] = [...rule, ...(allRules[name] ?? [])]
+		context.metadata[RuleMetaKey] = allRules
+	}
 }
 
-function addRuleToMetadata(target: any, propertyKey: string | symbol, ...rule: Validation.ValidationRule[]) {
-	updateMetadata<Validation.ValidationRule[]>({ key: RuleMetaKey, target, propertyKey }, prev => [...rule, ...prev], [])
+function getTC39Metadata(cls: Function): Record<string, Validation.ValidationRule[]> | undefined {
+	const metaSymbol = Symbol.metadata
+		?? Reflect.ownKeys(cls).find((k): k is symbol => typeof k === 'symbol' && String(k) === 'Symbol(Symbol.metadata)')
+	if (!metaSymbol) return undefined
+	const meta = (cls as any)[metaSymbol]
+	return meta?.[RuleMetaKey] as Record<string, Validation.ValidationRule[]> | undefined
 }
 
 export function fluent() {
@@ -72,8 +81,8 @@ export class RuleBranch {
 		const messageParsed: Validation.Message = typeof message === 'string' ? { text: message } : message
 		const newRules = [...this.branchRules, { validator, message: messageParsed }]
 		const branch = new RuleBranch(this.conditions, newRules)
-		const propertyDecorator: PropertyDecorator = (target: any, propertykey: string | symbol) => {
-			addRuleToMetadata(target, propertykey, ...branch.buildRules())
+		const propertyDecorator = (target: any, propertyKeyOrContext: any) => {
+			addRuleToMetadata(target, propertyKeyOrContext, ...branch.buildRules())
 		}
 		return Object.assign(propertyDecorator, branch)
 	}
@@ -191,10 +200,8 @@ export const assertPattern = (pattern: RegExp, message: MessageOrString) => flue
 export const assertMinLength = (min: number, message: MessageOrString) => fluent().assertMinLength(min, message)
 export const assertMaxLength = (min: number, message: MessageOrString) => fluent().assertMaxLength(min, message)
 
-export const combine =
-	(...decorators: PropertyDecorator[]): PropertyDecorator =>
-		(target, propertyKey) =>
-			decorators.forEach(it => it(target, propertyKey))
+export const combine = (...decorators: PropertyDecorator[]): PropertyDecorator => (target: any, propertyKeyOrContext: any) =>
+	decorators.forEach(it => (it as any)(target, propertyKeyOrContext))
 
 export function parseDefinition(
 	definitions: Record<string, any>,
@@ -204,11 +211,13 @@ export function parseDefinition(
 			const target = definition.prototype
 			const defInstance = new definition()
 			const fields = Object.keys(defInstance)
+			const tc39Rules = getTC39Metadata(definition)
 			return tuple(
 				name,
 				fields
 					.map(field => {
-						const fieldRules: Validation.ValidationRule[] | undefined = Reflect.getMetadata(RuleMetaKey, target, field)
+						const fieldRules: Validation.ValidationRule[] | undefined = tc39Rules?.[field]
+							?? (typeof Reflect.getMetadata === 'function' ? Reflect.getMetadata(RuleMetaKey, target, field) : undefined)
 						if (fieldRules === undefined) {
 							return tuple(field, [])
 						}

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

@@ -96,11 +96,9 @@ test('basic createSchema test', () => {
 	})
 })
 
-
 namespace StrictModel {
 	export class Genre {
 		name = c.stringColumn()
-
 	}
 	export class Book {
 		title = c.stringColumn()
@@ -109,10 +107,11 @@ namespace StrictModel {
 }
 
 test('strict test', () => {
-	const cb = () => createSchema(StrictModel, schema => ({
-		...schema,
-		settings: settingsPresets['v1.3'],
-	}), { strict: true })
+	const cb = () =>
+		createSchema(StrictModel, schema => ({
+			...schema,
+			settings: settingsPresets['v1.3'],
+		}), { strict: true })
 
 	expect(cb).toThrow(`Strict schema validation failed: 
 - Book.genre: inverse side of the relation is not defined.

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

@@ -1,6 +1,6 @@
 import { Model } from '@contember/schema'
 import { expect, test } from 'bun:test'
-import { createSchema, c } from '../../../src'
+import { c, createSchema } from '../../../src'
 import { extendEntity, FieldDefinition } from '../../../src/model/definition'
 import { DecoratorFunction } from '../../../src/utils'
 
@@ -26,7 +26,6 @@ namespace ExtendedModel {
 	addField('lead', c.stringColumn())(Article)
 }
 
-
 test('add a field to entity using an extension', () => {
 	const schema = createSchema(ExtendedModel)
 

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

@@ -2,7 +2,6 @@ import { Model } from '@contember/schema'
 import { describe, expect, test } from 'bun:test'
 import { c, createSchema } from '../../../src'
 
-
 const assert = {
 	deepEqual: (a: any, b: any) => expect(a).toStrictEqual(b),
 }
@@ -42,7 +41,6 @@ namespace LegacyOrderBy {
 }
 
 describe('order by', () => {
-
 	test('simple order by', () => {
 		const schema = createSchema(OrderByModel)
 
@@ -71,22 +69,21 @@ describe('order by', () => {
 	})
 
 	test('deprecated orderBy', () => {
-
 		const origWarn = console.warn
 		let msg = ''
 		console.warn = (m: string) => msg = m
 
 		const schema = createSchema(LegacyOrderBy)
 
-
 		assert.deepEqual(schema.model.entities.Entity5.orderBy, [
 			{ path: ['title'], direction: Model.OrderDirection.asc },
 			{ path: ['order'], direction: Model.OrderDirection.asc },
 		])
 
-		expect(msg).toBe('DEPRECATED: The "order by" property for the entity Entity5 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.')
+		expect(msg).toBe(
+			'DEPRECATED: The "order by" property for the entity Entity5 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 = origWarn
 	})
 })
-