@contember/schema-definition 2.0.0-alpha.12 → 2.0.0-alpha.13

package/src/index.ts

@@ -1,4 +1,5 @@
 import * as AclDefinition from './acl/definition'
+import { Role } from './acl/definition'
 import * as ActionsDefinition from './actions/definition'
 import * as InputValidation from './validation'
 import { SchemaDefinition } from './model'
@@ -9,6 +10,20 @@ export { PermissionsBuilder } from './acl/builder/PermissionsBuilder'
 export * from './model'
 export * from './presets'
 
+export type { Role }
+export type { VariableDefinition } from './acl/definition'
+export type {
+	ColumnDefinition,
+	FieldDefinition,
+	OneHasOneDefinition,
+	OneHasOneInverseDefinition,
+	OneHasManyDefinition,
+	ManyHasOneDefinition,
+	ManyHasManyDefinition,
+	ManyHasManyInverseDefinition,
+	EnumDefinition,
+} from './model/definition'
+
 export { AclDefinition, ActionsDefinition, SchemaDefinition, InputValidation, createSchema }
 
 export const c = {

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

@@ -1,5 +1,4 @@
 import { Model } from '@contember/schema'
-import { Interface } from '../types'
 import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
 import { EnumDefinition } from '../EnumDefinition'
 import { resolveDefaultColumnType } from '@contember/schema-utils'
@@ -7,6 +6,7 @@ import { resolveDefaultColumnType } from '@contember/schema-utils'
 export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 	type = 'ColumnDefinition' as const
 
+
 	public static create(
 		type: Model.ColumnType,
 		typeOptions: ColumnTypeOptions = {},
@@ -18,35 +18,35 @@ export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 	}
 
 
-	public columnName(columnName: string): Interface<ColumnDefinition> {
+	public columnName(columnName: string): ColumnDefinition {
 		return this.withOption('columnName', columnName)
 	}
 
-	public columnType(columnType: string): Interface<ColumnDefinition> {
+	public columnType(columnType: string): ColumnDefinition {
 		return this.withOption('columnType', columnType)
 	}
 
-	public nullable(): Interface<ColumnDefinition> {
+	public nullable(): ColumnDefinition {
 		return this.withOption('nullable', true)
 	}
 
-	public notNull(): Interface<ColumnDefinition> {
+	public notNull(): ColumnDefinition {
 		return this.withOption('nullable', false)
 	}
 
-	public sequence(options?: Partial<Model.ColumnTypeDefinition['sequence']>): Interface<ColumnDefinition> {
+	public sequence(options?: Partial<Model.ColumnTypeDefinition['sequence']>): ColumnDefinition {
 		return this.withOption('sequence', { precedence: 'BY DEFAULT', ...options })
 	}
 
-	public unique(options: { timing?: Model.ConstraintTiming } = {}): Interface<ColumnDefinition> {
+	public unique(options: { timing?: Model.ConstraintTiming } = {}): ColumnDefinition {
 		return this.withOption('unique', options)
 	}
 
-	public default(value: ColumnDefinition['options']['default']): Interface<ColumnDefinition> {
+	public default(value: ColumnDefinition['options']['default']): ColumnDefinition {
 		return this.withOption('default', value)
 	}
 
-	public typeAlias(alias: string): Interface<ColumnDefinition> {
+	public typeAlias(alias: string): ColumnDefinition {
 		return this.withOption('typeAlias', alias)
 	}
 
@@ -83,45 +83,49 @@ export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 			...(typeAlias !== undefined ? { typeAlias } : {}),
 		}
 	}
+
+	protected withOption<K extends keyof ColumnDefinitionOptions>(key: K, value: ColumnDefinitionOptions[K]): ColumnDefinition {
+		return new ColumnDefinition({ ...this.options, [key]: value })
+	}
 }
 
 export function column(type: Model.ColumnType, typeOptions: ColumnTypeOptions = {}) {
 	return ColumnDefinition.create(type, typeOptions)
 }
 
-export function stringColumn() {
+export function stringColumn(): ColumnDefinition {
 	return column(Model.ColumnType.String)
 }
 
-export function intColumn() {
+export function intColumn(): ColumnDefinition {
 	return column(Model.ColumnType.Int)
 }
 
-export function boolColumn() {
+export function boolColumn(): ColumnDefinition {
 	return column(Model.ColumnType.Bool)
 }
 
-export function doubleColumn() {
+export function doubleColumn(): ColumnDefinition {
 	return column(Model.ColumnType.Double)
 }
 
-export function dateColumn() {
+export function dateColumn(): ColumnDefinition {
 	return column(Model.ColumnType.Date)
 }
 
-export function dateTimeColumn() {
+export function dateTimeColumn(): ColumnDefinition {
 	return column(Model.ColumnType.DateTime)
 }
 
-export function jsonColumn() {
+export function jsonColumn(): ColumnDefinition {
 	return column(Model.ColumnType.Json)
 }
 
-export function enumColumn(enumDefinition: EnumDefinition) {
+export function enumColumn(enumDefinition: EnumDefinition): ColumnDefinition {
 	return column(Model.ColumnType.Enum, { enumDefinition })
 }
 
-export function uuidColumn() {
+export function uuidColumn(): ColumnDefinition {
 	return column(Model.ColumnType.Uuid)
 }
 

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

@@ -2,12 +2,8 @@ import { Model } from '@contember/schema'
 import { CommonContext } from '../context'
 
 export abstract class FieldDefinition<O> {
-	constructor(public readonly options: O) {}
-
-	protected withOption<K extends keyof O>(this: any, key: K, value: O[K]): { [K in keyof this]: this[K] } {
-		return new this.constructor({ ...this.options, [key]: value })
+	constructor(public readonly options: O) {
 	}
-
 	abstract createField(context: CreateFieldContext): Model.AnyField
 }
 

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

@@ -1,22 +1,22 @@
 import { Model } from '@contember/schema'
-import { EntityConstructor, Interface, RelationTarget } from '../types'
+import { EntityConstructor, RelationTarget } from '../types'
 import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
 
-export class ManyHasManyDefinitionImpl extends FieldDefinition<ManyHasManyDefinitionOptions> {
+export class ManyHasManyDefinition extends FieldDefinition<ManyHasManyDefinitionOptions> {
 	type = 'ManyHasManyDefinition' as const
 
-	inversedBy(inversedBy: string): Interface<ManyHasManyDefinition> {
+	inversedBy(inversedBy: string): ManyHasManyDefinition {
 		return this.withOption('inversedBy', inversedBy)
 	}
 
-	joiningTable(joiningTable: Partial<Model.JoiningTable>): Interface<ManyHasManyDefinition> {
+	joiningTable(joiningTable: Partial<Model.JoiningTable>): ManyHasManyDefinition {
 		return this.withOption('joiningTable', joiningTable)
 	}
 
 	orderBy(
 		field: string | string[],
 		direction: Model.OrderDirection | `${Model.OrderDirection}` = Model.OrderDirection.asc,
-	): Interface<ManyHasManyDefinition> {
+	): ManyHasManyDefinition {
 		const path = typeof field === 'string' ? [field] : field
 		return this.withOption('orderBy', [...(this.options.orderBy || []), { path, direction: direction as Model.OrderDirection }])
 	}
@@ -48,12 +48,16 @@ export class ManyHasManyDefinitionImpl extends FieldDefinition<ManyHasManyDefini
 			...(options.orderBy ? { orderBy: options.orderBy } : {}),
 		}
 	}
+
+
+	protected withOption<K extends keyof ManyHasManyDefinitionOptions>(key: K, value: ManyHasManyDefinitionOptions[K]): ManyHasManyDefinition {
+		return new ManyHasManyDefinition({ ...this.options, [key]: value })
+	}
 }
 
-export type ManyHasManyDefinition = Interface<ManyHasManyDefinitionImpl>
 
 export function manyHasMany(target: EntityConstructor, inversedBy?: string): ManyHasManyDefinition {
-	return new ManyHasManyDefinitionImpl({ target, inversedBy })
+	return new ManyHasManyDefinition({ target, inversedBy })
 }
 
 export type ManyHasManyDefinitionOptions = {

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

@@ -1,14 +1,14 @@
 import { Model } from '@contember/schema'
 import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
-import { EntityConstructor, Interface, RelationTarget } from '../types'
+import { EntityConstructor, RelationTarget } from '../types'
 
-export class ManyHasManyInverseDefinitionImpl extends FieldDefinition<ManyHasManyInverseDefinitionOptions> {
+export class ManyHasManyInverseDefinition extends FieldDefinition<ManyHasManyInverseDefinitionOptions> {
 	type = 'ManyHasManyInverseDefinition' as const
 
 	orderBy(
 		field: string | string[],
 		direction: Model.OrderDirection | `${Model.OrderDirection}` = Model.OrderDirection.asc,
-	): Interface<ManyHasManyInverseDefinition> {
+	): ManyHasManyInverseDefinition {
 		const path = typeof field === 'string' ? [field] : field
 		return this.withOption('orderBy', [...(this.options.orderBy || []), { path, direction: direction as Model.OrderDirection }])
 	}
@@ -23,19 +23,15 @@ export class ManyHasManyInverseDefinitionImpl extends FieldDefinition<ManyHasMan
 			...(options.orderBy ? { orderBy: options.orderBy } : {}),
 		}
 	}
+
+	protected withOption<K extends keyof ManyHasManyInverseDefinitionOptions>(key: K, value: ManyHasManyInverseDefinitionOptions[K]): ManyHasManyInverseDefinition {
+		return new ManyHasManyInverseDefinition({ ...this.options, [key]: value })
+	}
 }
 
-export type ManyHasManyInverseDefinition = Interface<ManyHasManyInverseDefinitionImpl>
-/** @deprecated use ManyHasManyInverseDefinition */
-export type ManyHasManyInversedDefinition = Interface<ManyHasManyInverseDefinitionImpl>
 
 export function manyHasManyInverse(target: EntityConstructor, ownedBy: string): ManyHasManyInverseDefinition {
-	return new ManyHasManyInverseDefinitionImpl({ target, ownedBy })
-}
-
-/** @deprecated use manyHasManyInverse */
-export function manyHasManyInversed(target: EntityConstructor, ownedBy: string): ManyHasManyInverseDefinition {
-	return new ManyHasManyInverseDefinitionImpl({ target, ownedBy })
+	return new ManyHasManyInverseDefinition({ target, ownedBy })
 }
 
 export type ManyHasManyInverseDefinitionOptions = {

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

@@ -1,35 +1,35 @@
-import { EntityConstructor, Interface, RelationTarget } from '../types'
+import { EntityConstructor,  RelationTarget } from '../types'
 import { Model } from '@contember/schema'
 import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
 
-export class ManyHasOneDefinitionImpl extends FieldDefinition<ManyHasOneDefinitionOptions> {
+export class ManyHasOneDefinition extends FieldDefinition<ManyHasOneDefinitionOptions> {
 	type = 'ManyHasOneDefinition' as const
 
-	inversedBy(inversedBy: string): Interface<ManyHasOneDefinition> {
+	inversedBy(inversedBy: string): ManyHasOneDefinition {
 		return this.withOption('inversedBy', inversedBy)
 	}
 
-	joiningColumn(columnName: string): Interface<ManyHasOneDefinition> {
+	joiningColumn(columnName: string): ManyHasOneDefinition {
 		return this.withOption('joiningColumn', { ...this.options.joiningColumn, columnName })
 	}
 
-	onDelete(onDelete: Model.OnDelete | `${Model.OnDelete}`): Interface<ManyHasOneDefinition> {
+	onDelete(onDelete: Model.OnDelete | `${Model.OnDelete}`): ManyHasOneDefinition {
 		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: onDelete as Model.OnDelete })
 	}
 
-	cascadeOnDelete(): Interface<ManyHasOneDefinition> {
+	cascadeOnDelete(): ManyHasOneDefinition {
 		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: Model.OnDelete.cascade })
 	}
 
-	setNullOnDelete(): Interface<ManyHasOneDefinition> {
+	setNullOnDelete(): ManyHasOneDefinition {
 		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: Model.OnDelete.setNull })
 	}
 
-	restrictOnDelete(): Interface<ManyHasOneDefinition> {
+	restrictOnDelete(): ManyHasOneDefinition {
 		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: Model.OnDelete.restrict })
 	}
 
-	notNull(): Interface<ManyHasOneDefinition> {
+	notNull(): ManyHasOneDefinition {
 		return this.withOption('nullable', false)
 	}
 
@@ -51,12 +51,14 @@ export class ManyHasOneDefinitionImpl extends FieldDefinition<ManyHasOneDefiniti
 			},
 		}
 	}
-}
 
-export type ManyHasOneDefinition = Interface<ManyHasOneDefinitionImpl>
+	protected withOption<K extends keyof ManyHasOneDefinitionOptions>(key: K, value: ManyHasOneDefinitionOptions[K]): ManyHasOneDefinition {
+		return new ManyHasOneDefinition({ ...this.options, [key]: value })
+	}
+}
 
 export function manyHasOne(target: EntityConstructor, inversedBy?: string): ManyHasOneDefinition {
-	return new ManyHasOneDefinitionImpl({ target, inversedBy })
+	return new ManyHasOneDefinition({ target, inversedBy })
 }
 
 export type ManyHasOneDefinitionOptions = {

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

@@ -1,14 +1,14 @@
 import { Model } from '@contember/schema'
 import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
-import { EntityConstructor, Interface, RelationTarget } from '../types'
+import { EntityConstructor, RelationTarget } from '../types'
 
-export class OneHasManyDefinitionImpl extends FieldDefinition<OneHasManyDefinitionOptions> {
+export class OneHasManyDefinition extends FieldDefinition<OneHasManyDefinitionOptions> {
 	type = 'OneHasManyDefinition' as const
 
 	orderBy(
 		field: string | string[],
 		direction: Model.OrderDirection | `${Model.OrderDirection}` = Model.OrderDirection.asc,
-	): Interface<OneHasManyDefinition> {
+	): OneHasManyDefinition {
 		const path = typeof field === 'string' ? [field] : field
 		return this.withOption('orderBy', [...(this.options.orderBy || []), { path, direction: direction as Model.OrderDirection }])
 	}
@@ -22,12 +22,15 @@ export class OneHasManyDefinitionImpl extends FieldDefinition<OneHasManyDefiniti
 			...(options.orderBy ? { orderBy: options.orderBy } : {}),
 		}
 	}
+
+	protected withOption<K extends keyof OneHasManyDefinitionOptions>(key: K, value: OneHasManyDefinitionOptions[K]): OneHasManyDefinition {
+		return new OneHasManyDefinition({ ...this.options, [key]: value })
+	}
 }
 
-export type OneHasManyDefinition = Interface<OneHasManyDefinitionImpl>
 
 export function oneHasMany(target: EntityConstructor, ownedBy: string): OneHasManyDefinition {
-	return new OneHasManyDefinitionImpl({ target, ownedBy })
+	return new OneHasManyDefinition({ target, ownedBy })
 }
 
 export type OneHasManyDefinitionOptions = {

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

@@ -1,39 +1,40 @@
 import { Model } from '@contember/schema'
-import { EntityConstructor, Interface, RelationTarget } from '../types'
+import { EntityConstructor, RelationTarget } from '../types'
 import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
 
-export class OneHasOneDefinitionImpl extends FieldDefinition<OneHasOneDefinitionOptions> {
+export class OneHasOneDefinition extends FieldDefinition<OneHasOneDefinitionOptions> {
 	type = 'OneHasOneDefinition' as const
 
-	inversedBy(inversedBy: string): Interface<OneHasOneDefinition> {
+
+	inversedBy(inversedBy: string): OneHasOneDefinition {
 		return this.withOption('inversedBy', inversedBy)
 	}
 
-	joiningColumn(columnName: string): Interface<OneHasOneDefinition> {
+	joiningColumn(columnName: string): OneHasOneDefinition {
 		return this.withOption('joiningColumn', { ...this.joiningColumn, columnName })
 	}
 
-	onDelete(onDelete: Model.OnDelete | `${Model.OnDelete}`): Interface<OneHasOneDefinition> {
+	onDelete(onDelete: Model.OnDelete | `${Model.OnDelete}`): OneHasOneDefinition {
 		return this.withOption('joiningColumn', { ...this.joiningColumn, onDelete: onDelete as Model.OnDelete })
 	}
 
-	cascadeOnDelete(): Interface<OneHasOneDefinition> {
+	cascadeOnDelete(): OneHasOneDefinition {
 		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: Model.OnDelete.cascade })
 	}
 
-	setNullOnDelete(): Interface<OneHasOneDefinition> {
+	setNullOnDelete(): OneHasOneDefinition {
 		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: Model.OnDelete.setNull })
 	}
 
-	restrictOnDelete(): Interface<OneHasOneDefinition> {
+	restrictOnDelete(): OneHasOneDefinition {
 		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: Model.OnDelete.restrict })
 	}
 
-	notNull(): Interface<OneHasOneDefinition> {
+	notNull(): OneHasOneDefinition {
 		return this.withOption('nullable', false)
 	}
 
-	removeOrphan(): Interface<OneHasOneDefinition> {
+	removeOrphan(): OneHasOneDefinition {
 		return this.withOption('orphanRemoval', true)
 	}
 
@@ -57,12 +58,15 @@ export class OneHasOneDefinitionImpl extends FieldDefinition<OneHasOneDefinition
 			...(options.orphanRemoval ? { orphanRemoval: true } : {}),
 		}
 	}
+
+	protected withOption<K extends keyof OneHasOneDefinitionOptions>(key: K, value: OneHasOneDefinitionOptions[K]): OneHasOneDefinition {
+		return new OneHasOneDefinition({ ...this.options, [key]: value })
+	}
 }
 
-export type OneHasOneDefinition = Interface<OneHasOneDefinitionImpl>
 
 export function oneHasOne(target: EntityConstructor, inversedBy?: string): OneHasOneDefinition {
-	return new OneHasOneDefinitionImpl({ target, inversedBy })
+	return new OneHasOneDefinition({ target, inversedBy })
 }
 
 export type OneHasOneDefinitionOptions = {

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

@@ -1,12 +1,12 @@
 import { Model } from '@contember/schema'
-import { EntityConstructor, Interface } from '../types'
+import { EntityConstructor } from '../types'
 import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
 import { RelationTarget } from '../types'
 
-export class OneHasOneInverseDefinitionImpl extends FieldDefinition<OneHasOneInverseDefinitionOptions> {
+export class OneHasOneInverseDefinition extends FieldDefinition<OneHasOneInverseDefinitionOptions> {
 	type = 'OneHasOneInverseDefinition' as const
 
-	notNull(): Interface<OneHasOneInverseDefinition> {
+	notNull() {
 		return this.withOption('nullable', false)
 	}
 
@@ -20,20 +20,17 @@ export class OneHasOneInverseDefinitionImpl extends FieldDefinition<OneHasOneInv
 			nullable: options.nullable === undefined ? true : options.nullable,
 		}
 	}
+
+	protected withOption<K extends keyof OneHasOneInverseDefinitionOptions>(this: any, key: K, value: OneHasOneInverseDefinitionOptions[K]): OneHasOneInverseDefinition {
+		return new this.constructor({ ...this.options, [key]: value })
+	}
 }
 
-export type OneHasOneInverseDefinition = Interface<OneHasOneInverseDefinitionImpl>
-/** @deprecated use OneHasOneInverseDefinition */
-export type OneHasOneInversedDefinition = Interface<OneHasOneInverseDefinitionImpl>
 
 export function oneHasOneInverse(target: EntityConstructor, ownedBy: string): OneHasOneInverseDefinition {
-	return new OneHasOneInverseDefinitionImpl({ target, ownedBy })
+	return new OneHasOneInverseDefinition({ target, ownedBy })
 }
 
-/** @deprecated use oneHasOneInverse */
-export function oneHasOneInversed(target: EntityConstructor, ownedBy: string): OneHasOneInverseDefinition {
-	return new OneHasOneInverseDefinitionImpl({ target, ownedBy })
-}
 
 export type OneHasOneInverseDefinitionOptions = {
 	target: RelationTarget

package/src/model/definition/index.ts

@@ -1,4 +1,3 @@
-import { Interface } from './types'
 import { Model } from '@contember/schema'
 import { EnumDefinition } from './EnumDefinition'
 import { SchemaBuilder } from './internal'
@@ -18,7 +17,7 @@ export * from './ViewDefinition'
 export { extendEntity, type EntityExtension } from './extensions'
 
 export abstract class Entity {
-	[key: string]: Interface<FieldDefinition<any>> | undefined
+	[key: string]: FieldDefinition<any> | undefined
 }
 
 export type ModelDefinition<M> = {

package/src/model/definition/types.ts

@@ -1,7 +1,6 @@
-import { FieldDefinition } from './fieldDefinitions'
 import { EntityConstructor } from '../../utils'
+import { FieldDefinition } from './fieldDefinitions'
 
-export type Interface<T> = { [P in keyof T]: T[P] }
 export type RelationTarget = EntityConstructor
-export type FieldsDefinition = Record<string, Interface<FieldDefinition<any>>>
+export type FieldsDefinition = Record<string, FieldDefinition<any>>
 export { type EntityConstructor }