@contember/schema-utils 1.2.0-beta.1 → 1.2.0-beta.3

package/src/definition-generator/TsDefinitionGenerator.ts

@@ -0,0 +1,275 @@
+import { Model, Schema, Writable } from '@contember/schema'
+import {
+	acceptFieldVisitor,
+	DefaultNamingConventions,
+	isInverseRelation,
+	NamingConventions,
+	NamingHelper,
+	resolveDefaultColumnType,
+} from '../model'
+
+export class TsDefinitionGenerator {
+	private static reservedWords = new Set(['do', 'if', 'in', 'for', 'let', 'new', 'try', 'var', 'case', 'else', 'enum', 'eval', 'null', 'this', 'true', 'void', 'with', 'await', 'break', 'catch', 'class', 'const', 'false', 'super', 'throw', 'while', 'yield', 'delete', 'export', 'import', 'public', 'return', 'static', 'switch', 'typeof', 'default', 'extends', 'finally', 'package', 'private', 'continue', 'debugger', 'function', 'arguments', 'interface', 'protected', 'implements', 'instanceof'])
+
+	constructor(
+		private readonly schema: Schema,
+		private readonly conventions: NamingConventions = new DefaultNamingConventions(),
+	) {
+	}
+
+	public generate() {
+		const enums = Object.entries(this.schema.model.enums).map(([name, values]) => this.generateEnum({
+			name,
+			values,
+		})).join('')
+		const entities = Object.values(this.schema.model.entities).map(entity => this.generateEntity({ entity })).join('')
+		return `import { SchemaDefinition as def } from '@contember/schema-definition'
+${enums}${entities}`
+	}
+
+	private generateEnum({ name, values }: { name: string; values: readonly string[] }): string {
+		return `\nexport const ${this.formatIdentifier(name)} = def.createEnum(${values.map(it => this.formatLiteral(it)).join(', ')})\n`
+	}
+
+
+	public generateEntity({ entity }: { entity: Model.Entity }): string {
+		const decorators = [
+			...Object.values(entity.unique).map(constraint => this.generateUniqueConstraint({ entity, constraint })),
+			...Object.values(entity.indexes).map(index => this.generateIndex({ entity, index })),
+			this.generateView({ entity }),
+		].filter(it => !!it).map(it => `${it}\n`)
+
+		return `\n${decorators}export class ${this.formatIdentifier(entity.name)} {
+${Object.values(entity.fields).map(field => this.generateField({ field, entity })).filter(it => !!it).join('\n')}
+}\n`
+	}
+
+	private generateUniqueConstraint({ entity, constraint }: { entity: Model.Entity; constraint: Model.UniqueConstraint }): string {
+		const defaultName = NamingHelper.createUniqueConstraintName(entity.name, constraint.fields)
+		if (defaultName === constraint.name) {
+			const fieldsList = `${constraint.fields.map(it => this.formatLiteral(it)).join(', ')}`
+			return `@def.Unique(${fieldsList})`
+		}
+		return `@def.Unique(${this.formatLiteral(constraint)})`
+	}
+
+	private generateIndex({ entity, index }: { entity: Model.Entity; index: Model.Index }): string {
+		const defaultName = NamingHelper.createIndexName(entity.name, index.fields)
+		if (defaultName === index.name) {
+			const fieldsList = `${index.fields.map(it => this.formatLiteral(it)).join(', ')}`
+			return `@def.Index(${fieldsList})`
+		}
+		return `@def.Index(${this.formatLiteral(index)})`
+	}
+
+	private generateView({ entity }: { entity: Model.Entity }): string | undefined {
+		if (!entity.view) {
+			return undefined
+		}
+
+		const dependenciesExpr = (entity.view.dependencies?.length ?? 0) > 0
+			? `, {\n\tdependencies: () => [${entity.view.dependencies?.map(it => this.formatIdentifier(it))}]\n}`
+			: ''
+
+		return `@def.View(\`${entity.view.sql}\`${dependenciesExpr})`
+	}
+
+	public generateField({ entity, field }: { entity: Model.Entity; field: Model.AnyField }): string | undefined {
+		const formatRelationFactory = (method: string, relation: Model.AnyRelation) => {
+			const otherSide = isInverseRelation(relation) ? relation.ownedBy : relation.inversedBy
+			const otherSideFormatted = otherSide ? `, ${this.formatLiteral(otherSide)}` : ''
+			return `${method}(${this.formatIdentifier(relation.target)}${otherSideFormatted})`
+		}
+		const formatEnumRef = (enumName: string, enumValues: Record<string, string>, providedValue?: string, defaultValue?: string): string | undefined => {
+			if (!providedValue || providedValue === defaultValue) {
+				return undefined
+			}
+			const enumValueKey = Object.entries(Model.OrderDirection).find(dir => dir[1] === providedValue)?.[0]
+			if (!enumValueKey) {
+				throw new Error(`Value ${providedValue} is not defined in enum ${enumName}`)
+			}
+			return `${enumName}.${enumValueKey}`
+
+		}
+		const formatOrderBy = (orderBy?: readonly Model.OrderBy[]) => {
+			return orderBy?.map(it => {
+				const enumExpr = formatEnumRef(`Model.OrderDirection`, Model.OrderDirection, it.direction, Model.OrderDirection.asc)
+				return `orderBy(${this.formatLiteral(it.path)}${enumExpr ? `, ${enumExpr}` : ''})`
+			}) ?? []
+		}
+		const formatOnDelete = (onDelete?: Model.OnDelete): string | undefined => {
+			if (onDelete === Model.OnDelete.cascade) {
+				return 'cascadeOnDelete()'
+			}
+			if (onDelete === Model.OnDelete.setNull) {
+				return 'setNullOnDelete()'
+			}
+			return undefined
+		}
+		const formatJoiningColumn = (joiningColumnName: string, fieldName: string): string | undefined => {
+			const defaultJoiningColumn = this.conventions.getJoiningColumnName(fieldName)
+			if (defaultJoiningColumn === joiningColumnName) {
+				return undefined
+			}
+			return `joiningColumn(${this.formatLiteral(joiningColumnName)})`
+		}
+		const definition = acceptFieldVisitor<(string | undefined)[]>(this.schema.model, entity, field, {
+			visitColumn: ctx => {
+				return this.generateColumn(ctx)
+			},
+			visitOneHasMany: ({ relation }) => {
+				return [
+					formatRelationFactory('oneHasMany', relation),
+					...formatOrderBy(relation.orderBy),
+				]
+			},
+			visitManyHasOne: ({ relation }) => {
+				return [
+					formatRelationFactory('manyHasOne', relation),
+					!relation.nullable ? 'notNull()' : undefined,
+					formatOnDelete(relation.joiningColumn.onDelete),
+					formatJoiningColumn(relation.joiningColumn.columnName, relation.name),
+				]
+			},
+			visitOneHasOneInverse: ({ relation }) => {
+				return [
+					formatRelationFactory('oneHasOneInverse', relation),
+					!relation.nullable ? 'notNull()' : undefined,
+				]
+			},
+			visitOneHasOneOwning: ({ relation }) => {
+				return [
+					formatRelationFactory('oneHasOne', relation),
+					!relation.nullable ? 'notNull()' : undefined,
+					formatOnDelete(relation.joiningColumn.onDelete),
+					formatJoiningColumn(relation.joiningColumn.columnName, relation.name),
+					relation.orphanRemoval ? 'removeOrphan()' : undefined,
+				]
+			},
+			visitManyHasManyOwning: ({ entity, relation }) => {
+				const columnNames = this.conventions.getJoiningTableColumnNames(
+					entity.name,
+					relation.name,
+					relation.target,
+					relation.inversedBy,
+				)
+				const defaultJoiningTable = this.conventions.getJoiningTableName(entity.name, relation.name)
+				const joiningTable: Writable<Partial<Model.JoiningTable>> = {}
+				if (relation.joiningTable.tableName !== defaultJoiningTable) {
+					joiningTable.tableName = relation.joiningTable.tableName
+				}
+				if (!relation.joiningTable.eventLog.enabled) {
+					joiningTable.eventLog = { enabled: false }
+				}
+				if (columnNames[0] !== relation.joiningTable.joiningColumn.columnName || relation.joiningTable.joiningColumn.onDelete !== Model.OnDelete.cascade) {
+					joiningTable.joiningColumn = {
+						columnName: relation.joiningTable.joiningColumn.columnName,
+						onDelete: relation.joiningTable.joiningColumn.onDelete,
+					}
+				}
+				if (columnNames[1] !== relation.joiningTable.inverseJoiningColumn.columnName || relation.joiningTable.inverseJoiningColumn.onDelete !== Model.OnDelete.cascade) {
+					joiningTable.inverseJoiningColumn = {
+						columnName: relation.joiningTable.inverseJoiningColumn.columnName,
+						onDelete: relation.joiningTable.inverseJoiningColumn.onDelete,
+					}
+				}
+
+				return [
+					formatRelationFactory('manyHasMany', relation),
+					...formatOrderBy(relation.orderBy),
+					Object.keys(joiningTable).length > 0 ? `joiningTable(${this.formatLiteral(joiningTable)})` : undefined,
+				]
+			},
+			visitManyHasManyInverse: ({ relation }) => {
+				return [
+					formatRelationFactory('manyHasManyInverse', relation),
+					...formatOrderBy(relation.orderBy),
+				]
+			},
+		})
+		const definitionCode = definition.filter(it => !!it).join('.')
+		if (field.name === 'id' && definitionCode === 'uuidColumn().notNull()') {
+			return undefined
+		}
+		return `\t${this.formatIdentifier(field.name)} = def.${definitionCode}`
+	}
+
+	private generateColumn({ entity, column }: { entity: Model.Entity; column: Model.AnyColumn }): string[] {
+		let parts: string[] = []
+		if (column.type === Model.ColumnType.Enum) {
+			parts.push(`enumColumn(${column.columnType})`)
+		} else {
+			parts.push(`${ColumnToMethodMapping[column.type]}()`)
+			const defaultColumnType = resolveDefaultColumnType(column.type)
+			if (defaultColumnType !== column.columnType) {
+				parts.push(`columnType(${this.formatLiteral(column.columnType)})`)
+			}
+		}
+		const defaultColumnName = this.conventions.getColumnName(column.name)
+		if (defaultColumnName !== column.columnName) {
+			parts.push(`columnName(${this.formatLiteral(column.columnName)})`)
+		}
+		if (!column.nullable) {
+			parts.push('notNull()')
+		}
+		if (column.default !== undefined) {
+			parts.push(`default(${this.formatLiteral(column.default)})`)
+		}
+		if (column.typeAlias) {
+			parts.push(`typeAlias(${this.formatLiteral(column.typeAlias)})`)
+		}
+
+
+		// todo: sequence
+		// todo: maybe single column unique()
+
+		return parts
+	}
+
+	private formatIdentifier(id: string): string {
+		// todo: validate
+		return id
+	}
+
+	private formatLiteral(value: any): string {
+		if (value === undefined || value === null || typeof value === 'boolean' || typeof value === 'number' || typeof value === 'function') {
+			return String(value)
+		}
+		if (typeof value === 'bigint') {
+			return value.toString(10) + 'n'
+		}
+		if (typeof value === 'string') {
+			return `'${value.replaceAll(/'/g, '\\\'')}'`
+		}
+		if (Array.isArray(value)) {
+			return `[${value.map(it => this.formatLiteral(it)).join(', ')}]`
+		}
+		return `{${Object.entries(value).map(([key, value]) => {
+			const formattedKey = this.isSimpleIdentifier(key) ? key : `[${this.formatLiteral(key)}]`
+			return `${formattedKey}: ${this.formatLiteral(value)}`
+		}).join(', ')}`
+	}
+	private isValidIdentifier(identifier: string): boolean {
+		if (!this.isSimpleIdentifier(identifier)) {
+			return false
+		}
+		return !TsDefinitionGenerator.reservedWords.has(identifier)
+	}
+
+	private isSimpleIdentifier(identifier: string): boolean {
+		return !!identifier.match(/^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/)
+	}
+}
+
+const ColumnToMethodMapping: {
+	[K in Exclude<Model.ColumnType, Model.ColumnType.Enum>]: string
+} = {
+	[Model.ColumnType.Bool]: 'boolColumn',
+	[Model.ColumnType.Date]: 'dateColumn',
+	[Model.ColumnType.DateTime]: 'dateTimeColumn',
+	[Model.ColumnType.Json]: 'jsonColumn',
+	[Model.ColumnType.Double]: 'doubleColumn',
+	[Model.ColumnType.Uuid]: 'uuidColumn',
+	[Model.ColumnType.Int]: 'intColumn',
+	[Model.ColumnType.String]: 'stringColumn',
+}

package/src/definition-generator/index.ts

@@ -0,0 +1 @@
+export * from './TsDefinitionGenerator'

package/src/index.ts

@@ -3,6 +3,8 @@ import { emptyModelSchema } from './model'
 import * as Typesafe from '@contember/typesafe'
 import { aclSchema, modelSchema, validationSchema, settingsSchema } from './type-schema'
 
+export * from './definition-generator'
+export * from './lax'
 export * from './model'
 export * from './acl'
 export * from './dataUtils'

package/src/lax/LaxSchemaConverter.ts

@@ -0,0 +1,213 @@
+import { Model, Schema, Writable } from '@contember/schema'
+import { LaxSchema, LaxSchemaColumn, LaxSchemaEnum, LaxSchemaField, LaxSchemaRelation } from './schema'
+import { DefaultNamingConventions, NamingConventions, resolveDefaultColumnType } from '../model'
+
+const simpleColumnTypes: { [K in LaxSchemaColumn['type']]: { type: Model.ColumnType; columnType: string } } = {
+	boolean: { type: Model.ColumnType.Bool, columnType: 'boolean' },
+	int: { type: Model.ColumnType.Int, columnType: 'integer' },
+	date: { type: Model.ColumnType.Date, columnType: 'date' },
+	datetime: { type: Model.ColumnType.DateTime, columnType: 'timestamptz' },
+	float: { type: Model.ColumnType.Double, columnType: 'double precision' },
+	json: { type: Model.ColumnType.Json, columnType: 'jsonb' },
+	string: { type: Model.ColumnType.String, columnType: 'text' },
+}
+
+const isColumnDefinition = (field: LaxSchemaField): field is LaxSchemaColumn => field.type in simpleColumnTypes
+
+export class LaxSchemaConverter {
+	constructor(
+		private readonly schema: LaxSchema,
+		private readonly conventions: NamingConventions = new DefaultNamingConventions(),
+	) {
+	}
+
+	public convert(): Schema {
+		const builder = new LaxSchemaBuilder(this.schema, this.conventions)
+		return builder.build()
+	}
+
+}
+
+class LaxSchemaBuilder {
+	private readonly entities: Record<string, Model.Entity> = {}
+	private readonly enums: Record<string, string[]> = {}
+
+	constructor(
+		private readonly schema: LaxSchema,
+		private readonly conventions: NamingConventions = new DefaultNamingConventions(),
+	) {
+	}
+
+	public build(): Schema {
+		for (const [entityName, entityDefinition] of Object.entries(this.schema.entities)) {
+			for (const [fieldName, fieldDefinition] of Object.entries(entityDefinition.fields)) {
+				if (isColumnDefinition(fieldDefinition)) {
+					this.processColumn(entityName, fieldName, fieldDefinition)
+
+				} else if (fieldDefinition.type === 'enum') {
+					this.processEnum(entityName, fieldName, fieldDefinition)
+
+				} else {
+					this.processRelation(entityName, fieldName, fieldDefinition)
+				}
+			}
+		}
+		return {
+			acl: { roles: {} },
+			settings: {},
+			validation: {},
+			model: {
+				enums: this.enums,
+				entities: this.entities,
+			},
+		}
+	}
+
+	private processColumn(entityName: string, fieldName: string, columnDef: LaxSchemaColumn) {
+		const columnName = this.conventions.getColumnName(fieldName)
+		this.registerField(entityName, {
+			name: fieldName,
+			columnName: columnName,
+			type: simpleColumnTypes[columnDef.type].type,
+			nullable: !columnDef.notNull,
+			columnType: simpleColumnTypes[columnDef.type].columnType,
+		})
+	}
+
+	private processEnum(entityName: string, fieldName: string, enumDef: LaxSchemaEnum) {
+		this.enums[enumDef.enumName] = Array.from(new Set([...this.enums[enumDef.enumName] ?? [], ...enumDef.values]))
+		const columnName = this.conventions.getColumnName(fieldName)
+		this.registerField(entityName, {
+			name: fieldName,
+			columnName: columnName,
+			type: Model.ColumnType.Enum,
+			nullable: !enumDef.notNull,
+			columnType: enumDef.enumName,
+		})
+	}
+
+	private processRelation(entityName: string, fieldName: string, relDef: LaxSchemaRelation) {
+		switch (relDef.type) {
+			case 'manyHasMany':
+				const joiningColumns = this.conventions.getJoiningTableColumnNames(entityName, fieldName, relDef.targetEntity, relDef.targetField)
+				this.registerField(entityName, {
+					type: Model.RelationType.ManyHasMany,
+					name: fieldName,
+					target: relDef.targetEntity,
+					inversedBy: relDef.targetField,
+					joiningTable: {
+						tableName: this.conventions.getJoiningTableName(entityName, fieldName),
+						joiningColumn: {
+							columnName: joiningColumns[0],
+							onDelete: Model.OnDelete.cascade,
+						},
+						inverseJoiningColumn: {
+							columnName: joiningColumns[1],
+							onDelete: Model.OnDelete.cascade,
+						},
+						eventLog: { enabled: true },
+					},
+				})
+				if (!this.schema.entities[relDef.targetEntity].fields[relDef.targetField]) {
+					this.processRelation(relDef.targetEntity, relDef.targetField, {
+						type: 'manyHasManyInverse',
+						targetEntity: entityName,
+						targetField: fieldName,
+					})
+				}
+				break
+			case 'manyHasManyInverse':
+				this.registerField(entityName, {
+					type: Model.RelationType.ManyHasMany,
+					name: fieldName,
+					target: relDef.targetEntity,
+					ownedBy: relDef.targetField,
+				})
+				break
+			case 'manyHasOne':
+				this.registerField(entityName, {
+					type: Model.RelationType.ManyHasOne,
+					name: fieldName,
+					target: relDef.targetEntity,
+					inversedBy: relDef.targetField,
+					joiningColumn: {
+						columnName: this.conventions.getJoiningColumnName(fieldName),
+						onDelete: Model.OnDelete.restrict,
+					},
+					nullable: !relDef.notNull,
+				})
+				if (!this.schema.entities[relDef.targetEntity].fields[relDef.targetField]) {
+					this.processRelation(relDef.targetEntity, relDef.targetField, {
+						type: 'oneHasMany',
+						targetEntity: entityName,
+						targetField: fieldName,
+					})
+				}
+				break
+			case 'oneHasMany':
+				this.registerField(entityName, {
+					type: Model.RelationType.OneHasMany,
+					name: fieldName,
+					target: relDef.targetEntity,
+					ownedBy: relDef.targetField,
+				})
+				break
+			case 'oneHasOne':
+				this.registerField(entityName, {
+					type: Model.RelationType.OneHasOne,
+					name: fieldName,
+					target: relDef.targetEntity,
+					inversedBy: relDef.targetField,
+					joiningColumn: {
+						columnName: this.conventions.getJoiningColumnName(fieldName),
+						onDelete: Model.OnDelete.restrict,
+					},
+					nullable: !relDef.notNull,
+				})
+				if (!this.schema.entities[relDef.targetEntity].fields[relDef.targetField]) {
+					this.processRelation(relDef.targetEntity, relDef.targetField, {
+						type: 'oneHasOneInverse',
+						targetEntity: entityName,
+						targetField: fieldName,
+					})
+				}
+				break
+			case 'oneHasOneInverse':
+				this.registerField(entityName, {
+					type: Model.RelationType.OneHasOne,
+					name: fieldName,
+					target: relDef.targetEntity,
+					ownedBy: relDef.targetField,
+					nullable: !relDef.notNull,
+				})
+				break
+		}
+	}
+
+	private registerField(entityName: string, field: Model.AnyField) {
+		const entity = this.getEntity(entityName)
+		;(entity.fields as Writable<Model.Entity['fields']>)[field.name] = field
+	}
+
+
+	private getEntity(entityName: string): Model.Entity {
+		return this.entities[entityName] ??= {
+			name: entityName,
+			unique: {},
+			indexes: {},
+			primary: 'id',
+			primaryColumn: 'id',
+			tableName: this.conventions.getTableName(entityName),
+			eventLog: { enabled: true },
+			fields: {
+				id: {
+					name: 'id',
+					columnName: 'id',
+					type: Model.ColumnType.Uuid,
+					columnType: resolveDefaultColumnType(Model.ColumnType.Uuid),
+					nullable: false,
+				},
+			},
+		}
+	}
+}

package/src/lax/index.ts

@@ -0,0 +1,2 @@
+export * from './schema'
+export { LaxSchemaConverter } from './LaxSchemaConverter'

package/src/lax/schema.ts

@@ -0,0 +1,62 @@
+import * as Typesafe from '@contember/typesafe'
+
+const LaxSchemaEnumInner = Typesafe.intersection(
+	Typesafe.object({
+		values: Typesafe.array(Typesafe.string),
+		enumName: Typesafe.string,
+	}),
+	Typesafe.partial({
+		notNull: Typesafe.boolean,
+		unique: Typesafe.boolean,
+	}),
+)
+
+const LaxSchemaColumnInner = Typesafe.partial({
+	notNull: Typesafe.boolean,
+	unique: Typesafe.boolean,
+})
+
+const LaxSchemaRelationInner = Typesafe.intersection(
+	Typesafe.object({
+		targetEntity: Typesafe.string,
+		targetField: Typesafe.string,
+	}),
+	Typesafe.partial({
+		notNull: Typesafe.boolean,
+	}),
+)
+
+const LaxSchemaField = Typesafe.discriminatedUnion('type', {
+	oneHasOne: LaxSchemaRelationInner,
+	oneHasOneInverse: LaxSchemaRelationInner,
+	manyHasMany: LaxSchemaRelationInner,
+	manyHasManyInverse: LaxSchemaRelationInner,
+	oneHasMany: LaxSchemaRelationInner,
+	manyHasOne: LaxSchemaRelationInner,
+	int: LaxSchemaColumnInner,
+	float: LaxSchemaColumnInner,
+	boolean: LaxSchemaColumnInner,
+	string: LaxSchemaColumnInner,
+	json: LaxSchemaColumnInner,
+	date: LaxSchemaColumnInner,
+	datetime: LaxSchemaColumnInner,
+	enum: LaxSchemaEnumInner,
+})
+
+export type LaxSchemaField = ReturnType<typeof LaxSchemaField>
+export type LaxSchemaEnum = Extract<LaxSchemaField, { type: 'enum' }>
+export type LaxSchemaColumn = Extract<LaxSchemaField, { type: 'int' | 'float' | 'boolean' | 'string' | 'json' | 'datetime' | 'date' | 'uuid' }>
+export type LaxSchemaRelation = Extract<LaxSchemaField, {type: 'oneHasOne' | 'oneHasOneInverse' | 'manyHasMany' | 'manyHasManyInverse' | 'oneHasMany' | 'manyHasOne' }>
+
+const LaxSchemaEntity = Typesafe.object({
+	fields: Typesafe.record(Typesafe.string, LaxSchemaField),
+})
+export type LaxSchemaEntity = ReturnType<typeof LaxSchemaEntity>
+
+export const LaxSchema = Typesafe.object({
+	entities: Typesafe.record(
+		Typesafe.string,
+		LaxSchemaEntity,
+	),
+})
+export type LaxSchema = ReturnType<typeof LaxSchema>

package/src/model/NamingConventions.ts

@@ -0,0 +1,53 @@
+export interface NamingConventions {
+	getPrimaryField(): string
+
+	getColumnName(fieldName: string): string
+
+	getTableName(entityName: string): string
+
+	getJoiningColumnName(relationName: string): string
+
+	getJoiningTableName(entity: string, relation: string): string
+
+	getJoiningTableColumnNames(
+		owningEntity: string,
+		owningRelation: string,
+		inverseEntity: string,
+		inverseRelation?: string,
+	): [string, string]
+}
+
+const toUnderscore = (s: string) => s.replace(/([A-Z]+)/g, (x, y) => '_' + y.toLowerCase()).replace(/^_/, '')
+export class DefaultNamingConventions implements NamingConventions {
+	getPrimaryField(): string {
+		return 'id'
+	}
+
+	getColumnName(fieldName: string): string {
+		return toUnderscore(fieldName)
+	}
+
+	getTableName(entityName: string): string {
+		return toUnderscore(entityName)
+	}
+
+	getJoiningColumnName(relationName: string): string {
+		return toUnderscore(relationName) + '_id'
+	}
+
+	getJoiningTableName(entity: string, relation: string): string {
+		return toUnderscore(entity) + '_' + toUnderscore(relation)
+	}
+
+	getJoiningTableColumnNames(
+		owningEntity: string,
+		owningRelation: string,
+		inverseEntity: string,
+		inverseRelation?: string,
+	): [string, string] {
+		return [
+			toUnderscore(owningEntity) + '_id',
+			toUnderscore(inverseEntity === owningEntity ? owningRelation : inverseEntity) + '_id',
+		]
+	}
+}

package/src/model/index.ts

@@ -1,2 +1,4 @@
 export * from './modelUtils'
 export * from './NamingHelper'
+export * from './resolveDefaultColumnType'
+export * from './NamingConventions'

package/src/model/resolveDefaultColumnType.ts

@@ -0,0 +1,25 @@
+import { Model } from '@contember/schema'
+import { assertNever } from '../utils'
+
+export const resolveDefaultColumnType = (type: Exclude<Model.ColumnType, Model.ColumnType.Enum>): string => {
+	switch (type) {
+		case Model.ColumnType.Int:
+			return 'integer'
+		case Model.ColumnType.Double:
+			return 'double precision'
+		case Model.ColumnType.String:
+			return 'text'
+		case Model.ColumnType.Uuid:
+			return 'uuid'
+		case Model.ColumnType.Bool:
+			return 'boolean'
+		case Model.ColumnType.DateTime:
+			return 'timestamptz'
+		case Model.ColumnType.Date:
+			return 'date'
+		case Model.ColumnType.Json:
+			return 'jsonb'
+		default:
+			return assertNever(type)
+	}
+}

package/src/type-schema/model.ts

@@ -125,7 +125,7 @@ const columnSchema = Typesafe.intersection(
 )
 const columnSchemaCheck: Typesafe.Equals<Model.AnyColumn, ReturnType<typeof columnSchema>> = true
 
-const fieldSchema: Typesafe.Type<Model.AnyField> = Typesafe.discriminatedUnion(
+const fieldSchema: Typesafe.Type<Model.AnyField> = Typesafe.partiallyDiscriminatedUnion(
 	'type',
 	oneHasOneInverseRelationSchema,
 	oneHasOneOwningRelationSchema,