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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-definition",
-  "version": "2.0.0-alpha.9",
+  "version": "2.0.0-beta.2",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -23,15 +23,16 @@
     }
   },
   "dependencies": {
-    "@contember/schema": "2.0.0-alpha.9",
-    "@contember/schema-utils": "2.0.0-alpha.9",
-    "reflect-metadata": "^0.1.13"
+    "@contember/schema": "2.0.0-beta.2",
+    "@contember/schema-utils": "2.0.0-beta.2",
+    "reflect-metadata": "^0.2.2",
+    "fast-deep-equal": "^3.1.3"
   },
   "devDependencies": {
-    "graphql": "^16.8.1"
+    "graphql": "^16.9.0"
   },
   "peerDependencies": {
     "graphql": ">= 14.6.0"
   },
   "type": "module"
-}
+}

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

@@ -1,4 +1,4 @@
-import { isDeepStrictEqual } from 'node:util'
+import deepEqual from 'fast-deep-equal'
 
 import { Acl, Input, Model, Writable } from '@contember/schema'
 import { PredicateDefinitionProcessor } from '@contember/schema-utils'
@@ -88,7 +88,7 @@ export class EntityPredicatesResolver {
 			if (!(predicateName in this.predicates)) {
 				this.predicates[predicateName] = predicate
 				break
-			} else if (isDeepStrictEqual(predicate, this.predicates[predicateName])) {
+			} else if (deepEqual(predicate, this.predicates[predicateName])) {
 				break
 			} else {
 				predicateName = `${origName}_${i}`

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,53 @@ 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() {
-	return column(Model.ColumnType.DateTime)
+export function dateTimeColumn(args?: { precision?: number }): ColumnDefinition {
+	const col = column(Model.ColumnType.DateTime)
+	if (!args?.precision) {
+		return col
+	}
+	return col.columnType(`${resolveDefaultColumnType(Model.ColumnType.DateTime)}(${args.precision})`)
 }
 
-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/internal/SchemaBuilder.ts

@@ -32,6 +32,12 @@ export class SchemaBuilder {
 		const entities = Object.entries(this.entityRegistry.entities).map(([entityName, definition]): Model.Entity => {
 			const definitionInstance: FieldsDefinition = new definition()
 
+			Object.entries(definitionInstance).forEach(([fieldName, fieldDefinition]) => {
+				if (typeof fieldDefinition !== 'object' || !('createField' in fieldDefinition)) {
+					throw `Entity "${entityName}": field "${fieldName}" does not contain expected field definition. Check that you are correctly invoking methods of the definition builder.`
+				}
+			})
+
 			const primaryName = this.conventions.getPrimaryField()
 
 			const entity: Model.Entity = {

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 }

package/src/presets.ts

@@ -18,7 +18,19 @@ const v1_4preset: Settings.Schema = {
 	},
 }
 
+const v2_0preset: Settings.Schema = {
+	tenant: {
+		inviteExpirationMinutes: 60 * 24 * 7, // 7 days
+	},
+	content: {
+		shortDateResponse: true,
+		fullDateTimeResponse: true,
+		useExistsInHasManyFilter: true,
+	},
+}
+
 export const settingsPresets = {
 	'v1.3': v1_3preset,
 	'v1.4': v1_4preset,
+	'v2.0': v2_0preset,
 }

package/tests/cases/unit/__snapshots__/readActions.test.ts.snap

@@ -0,0 +1,33 @@
+// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`read actions schema 1`] = `
+{
+  "targets": {
+    "book_watch_target": {
+      "name": "book_watch_target",
+      "type": "webhook",
+      "url": "%webhookUrl%/book/updated",
+    },
+  },
+  "triggers": {
+    "book_watch": {
+      "entity": "Book",
+      "name": "book_watch",
+      "priority": 100,
+      "selection": undefined,
+      "target": "book_watch_target",
+      "type": "watch",
+      "watch": [
+        "title",
+        [
+          "tags",
+          {},
+          [
+            "name",
+          ],
+        ],
+      ],
+    },
+  },
+}
+`;