@contember/schema 1.1.0-alpha.3 → 1.1.0-alpha.6

package/src/schema/model.ts

@@ -1,24 +1,30 @@
 import Input from './input'
 
 namespace Model {
-	export interface Entity {
-		name: string
-		primary: string
-		primaryColumn: string
-		tableName: string
-		fields: { [name: string]: AnyField }
-		unique: UniqueConstraints
-		view?: View
+
+	export type Entity = {
+		readonly name: string
+		readonly primary: string
+		readonly primaryColumn: string
+		readonly tableName: string
+		readonly fields: { readonly [name: string]: AnyField }
+		readonly unique: UniqueConstraints
+		readonly view?: View
+		readonly eventLog: EventLogConfig
+	}
+
+	export type View = {
+		readonly sql: string
+		readonly dependencies?: readonly string[]
 	}
 
-	export interface View {
-		sql: string
-		dependencies?: string[]
+	export type EventLogConfig = {
+		readonly enabled: boolean
 	}
 
 	export type FieldType = RelationType | ColumnType
-	export interface Field<T extends FieldType> {
-		type: T
+	export type Field<T extends FieldType> = {
+		readonly type: T
 	}
 
 	export type AnyField = AnyColumn | AnyRelation
@@ -37,16 +43,22 @@ namespace Model {
 	}
 
 	export type Column<T extends ColumnType> = ColumnTypeDefinition<T> & {
-		name: string
-		columnName: string
+		readonly name: string
+		readonly columnName: string
 	}
 
-	export interface ColumnTypeDefinition<T extends ColumnType = ColumnType> extends Field<T> {
-		columnType: string
-		typeAlias?: string
-		nullable: boolean
-		default?: string | number | boolean | null
-	}
+	export type ColumnTypeDefinition<T extends ColumnType = ColumnType>  =
+		& Field<T>
+		& {
+			readonly columnType: string
+			readonly typeAlias?: string
+			readonly nullable: boolean
+			readonly default?: string | number | boolean | null
+			readonly sequence?: {
+				readonly precedence: 'ALWAYS' | 'BY DEFAULT'
+				readonly start?: number
+			}
+		}
 
 	export interface ColumnVisitor<T> {
 		visitColumn(entity: Entity, column: AnyColumn): T
@@ -141,25 +153,31 @@ namespace Model {
 
 	export type AnyRelation = AnyInverseRelation | AnyOwningRelation
 
-	export interface Relation<T extends RelationType = RelationType> extends Field<T> {
-		name: string
-		type: T
-		target: string
-	}
+	export type Relation<T extends RelationType = RelationType>=
+		& Field<T>
+		& {
+			readonly name: string
+			readonly type: T
+			readonly target: string
+		}
 
-	export interface InverseRelation extends Relation {
-		ownedBy: string
-	}
+	export type InverseRelation =
+		& Relation
+		& {
+			readonly ownedBy: string
+		}
 
 	/** @deprecated */
-	export interface InversedRelation extends InverseRelation {}
+	export type InversedRelation = InverseRelation
 
-	export interface OwningRelation extends Relation {
-		inversedBy?: string
-	}
+	export type OwningRelation =
+		& Relation
+		& {
+			readonly inversedBy?: string
+		}
 
 	/** @deprecated */
-	export interface OwnerRelation extends OwningRelation {}
+	export type OwnerRelation = OwningRelation
 
 	export enum OnDelete {
 		cascade = 'cascade',
@@ -168,33 +186,37 @@ namespace Model {
 	}
 
 	export type JoiningColumn = {
-		columnName: string
-		onDelete: OnDelete
+		readonly columnName: string
+		readonly onDelete: OnDelete
 	}
 
-	export interface JoiningColumnRelation {
-		joiningColumn: JoiningColumn
+	export type JoiningColumnRelation = {
+		readonly joiningColumn: JoiningColumn
 	}
 
-	export interface NullableRelation {
-		nullable: boolean
+	export type NullableRelation = {
+		readonly nullable: boolean
 	}
 
-	export interface JoiningTable {
-		tableName: string
-		joiningColumn: JoiningColumn
-		inverseJoiningColumn: JoiningColumn
+	export type JoiningTable = {
+		readonly tableName: string
+		readonly joiningColumn: JoiningColumn
+		readonly inverseJoiningColumn: JoiningColumn
+		readonly eventLog: EventLogConfig
 	}
 
-	export interface JoiningTableRelation {
-		joiningTable: JoiningTable
+	export type JoiningTableRelation = {
+		readonly joiningTable: JoiningTable
 	}
 
 	export import OrderDirection = Input.OrderDirection
-	export type OrderBy = { path: string[]; direction: OrderDirection }
+	export type OrderBy = {
+		readonly path: readonly string[]
+		readonly direction: OrderDirection
+	}
 
-	export interface OrderableRelation {
-		orderBy?: OrderBy[]
+	export type OrderableRelation = {
+		readonly orderBy?: readonly OrderBy[]
 	}
 
 	export type OneHasManyRelation =
@@ -221,7 +243,7 @@ namespace Model {
 		& JoiningColumnRelation
 		& NullableRelation
 		& {
-			orphanRemoval?: true
+			readonly orphanRemoval?: true
 		}
 	/** @deprecated */
 	export type OneHasOneOwnerRelation = OneHasOneOwningRelation
@@ -241,18 +263,18 @@ namespace Model {
 	/** @deprecated */
 	export type ManyHasManyOwnerRelation = ManyHasManyOwningRelation
 
-	export interface Schema {
-		enums: { [name: string]: string[] }
-		entities: { [name: string]: Entity }
+	export type Schema = {
+		readonly enums: { readonly [name: string]: readonly string[] }
+		readonly entities: { readonly [name: string]: Entity }
 	}
 
-	export interface UniqueConstraints {
-		[name: string]: UniqueConstraint
+	export type UniqueConstraints = {
+		readonly [name: string]: UniqueConstraint
 	}
 
-	export interface UniqueConstraint {
-		fields: string[]
-		name: string
+	export type UniqueConstraint = {
+		readonly fields: readonly string[]
+		readonly name: string
 	}
 }
 

package/src/schema/validation.ts

@@ -1,5 +1,7 @@
+import { JSONValue } from './json'
+
 namespace Validation {
-	export type ContextPath = string[]
+	export type ContextPath = readonly string[]
 
 	export enum ArgumentType {
 		validator = 'validator',
@@ -7,47 +9,61 @@ namespace Validation {
 		literal = 'literal',
 	}
 
-	export type ValidatorArgument = { type: ArgumentType.validator; validator: Validator }
-	export type PathArgument = { type: ArgumentType.path; path: ContextPath }
-	export type LiteralArgument<V = any> = { type: ArgumentType.literal; value: V }
+	export type ValidatorArgument = {
+		readonly type: ArgumentType.validator
+		readonly validator: Validator
+	}
+	export type PathArgument = {
+		readonly type: ArgumentType.path
+		readonly path: ContextPath
+	}
+	export type LiteralArgument<V = JSONValue> = {
+		readonly type: ArgumentType.literal
+		readonly value: V
+	}
 
 	export type ValidatorArguments = {
-		and: ValidatorArgument[]
-		or: ValidatorArgument[]
-		conditional: [ValidatorArgument, ValidatorArgument]
-		pattern: [LiteralArgument<[string, string]>]
-		lengthRange: [LiteralArgument<number | null>, LiteralArgument<number | null>]
-		range: [LiteralArgument<number | null>, LiteralArgument<number | null>]
-		equals: [LiteralArgument<any>]
-		not: [ValidatorArgument]
-		empty: []
-		defined: []
-		inContext: [PathArgument, ValidatorArgument]
-		every: [ValidatorArgument]
-		any: [ValidatorArgument]
-		filter: [ValidatorArgument, ValidatorArgument]
+		readonly and: readonly ValidatorArgument[]
+		readonly or: readonly ValidatorArgument[]
+		readonly conditional: readonly [ValidatorArgument, ValidatorArgument]
+		readonly pattern: readonly [LiteralArgument<readonly [string, string]>]
+		readonly lengthRange: readonly [LiteralArgument<number | null>, LiteralArgument<number | null>]
+		readonly range: readonly [LiteralArgument<number | null>, LiteralArgument<number | null>]
+		readonly equals: readonly [LiteralArgument<JSONValue>]
+		readonly not: readonly [ValidatorArgument]
+		readonly empty: readonly[]
+		readonly defined: readonly[]
+		readonly inContext: readonly [PathArgument, ValidatorArgument]
+		readonly every: readonly [ValidatorArgument]
+		readonly any: readonly [ValidatorArgument]
+		readonly filter: readonly [ValidatorArgument, ValidatorArgument]
 	}
 
 	export type SpecificValidator<N extends keyof ValidatorArguments> = {
-		operation: N
-		args: ValidatorArguments[N]
+		readonly operation: N
+		readonly args: ValidatorArguments[N]
 	}
 
-	export type Validator = { [N in keyof ValidatorArguments]: SpecificValidator<N> }[keyof ValidatorArguments]
+	export type Validator = {
+		readonly [N in keyof ValidatorArguments]: SpecificValidator<N>
+	}[keyof ValidatorArguments]
 
-	export type Message = { text: string; parameters?: (string | number)[] }
+	export type Message = {
+		readonly text: string
+		readonly parameters?: readonly (string | number)[]
+	}
 
-	export interface ValidationRule {
-		validator: Validator
-		message: Message
+	export type ValidationRule = {
+		readonly validator: Validator
+		readonly message: Message
 	}
 
-	export interface EntityRules {
-		[field: string]: ValidationRule[]
+	export type EntityRules = {
+		readonly [field: string]: readonly ValidationRule[]
 	}
 
-	export interface Schema {
-		[entity: string]: EntityRules
+	export type Schema = {
+		readonly [entity: string]: EntityRules
 	}
 }
 

package/src/schema/value.ts

@@ -1,9 +1,9 @@
 namespace Value {
-	export interface Object<E = never> {
-		[key: string]: FieldValue<E>
+	export type Object<E = never> = {
+		readonly [key: string]: FieldValue<E>
 	}
 
-	export interface List<E = never> extends Array<FieldValue<E>> {}
+	export type List<E = never> = readonly FieldValue<E>[]
 
 	export type PrimaryValue<E = never> = string | number | E