@contember/schema-utils 1.3.0-alpha.5 → 1.3.0-alpha.7

package/src/definition-generator/DefinitionCodeGenerator.ts

@@ -0,0 +1,259 @@
+import { Acl, Model, Schema, Writable } from '@contember/schema'
+import {
+	acceptFieldVisitor,
+	DefaultNamingConventions,
+	isInverseRelation,
+	NamingConventions,
+	NamingHelper,
+	resolveDefaultColumnType,
+} from '../model'
+import { printJsValue } from '../utils/printJsValue'
+import { DefinitionNamingConventions } from './DefinitionNamingConventions'
+import { AclDefinitionCodeGenerator } from './AclDefinitionCodeGenerator'
+
+
+export class DefinitionCodeGenerator {
+	constructor(
+		private readonly schemaNamingConventions: NamingConventions = new DefaultNamingConventions(),
+		private readonly definitionNamingConventions = new DefinitionNamingConventions(),
+		private readonly aclGenerator = new AclDefinitionCodeGenerator(),
+	) {
+	}
+
+	public generate(schema: Schema) {
+		const roles = this.aclGenerator.generateRoles({ acl: schema.acl })
+		const aclVariables = this.aclGenerator.generateAclVariables({ acl: schema.acl })
+
+		const enums = Object.entries(schema.model.enums).map(([name, values]) => this.generateEnum({
+			name,
+			values,
+		})).join('')
+
+		const entities = Object.values(schema.model.entities).map(entity => this.generateEntity({ entity, schema })).join('')
+
+		return `import { SchemaDefinition as def, AclDefinition as acl } from '@contember/schema-definition'
+${roles}${aclVariables}${enums}${entities}`
+	}
+
+
+	private generateEnum({ name, values }: { name: string; values: readonly string[] }): string {
+		return `\nexport const ${this.formatIdentifier(name)} = def.createEnum(${values.map(it => printJsValue(it)).join(', ')})\n`
+	}
+
+	public generateEntity({ entity, schema }: { entity: Model.Entity; schema: Schema }): 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`).join('')
+		const acl = this.aclGenerator.generateEntityAcl({ entity, schema })
+
+		return `\n${decorators}${acl}export class ${this.formatIdentifier(entity.name)} {
+${Object.values(entity.fields).map(field => this.generateField({ field, entity, schema })).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 => printJsValue(it)).join(', ')}`
+			return `@def.Unique(${fieldsList})`
+		}
+		return `@def.Unique(${printJsValue(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 => printJsValue(it)).join(', ')}`
+			return `@def.Index(${fieldsList})`
+		}
+		return `@def.Index(${printJsValue(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, schema }: { entity: Model.Entity; field: Model.AnyField; schema: Schema }): string | undefined {
+		const formatRelationFactory = (method: string, relation: Model.AnyRelation) => {
+			const otherSide = isInverseRelation(relation) ? relation.ownedBy : relation.inversedBy
+			const otherSideFormatted = otherSide ? `, ${printJsValue(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(${printJsValue(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.schemaNamingConventions.getJoiningColumnName(fieldName)
+			if (defaultJoiningColumn === joiningColumnName) {
+				return undefined
+			}
+			return `joiningColumn(${printJsValue(joiningColumnName)})`
+		}
+		const definition = acceptFieldVisitor<(string | undefined)[]>(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.schemaNamingConventions.getJoiningTableColumnNames(
+					entity.name,
+					relation.name,
+					relation.target,
+					relation.inversedBy,
+				)
+				const defaultJoiningTable = this.schemaNamingConventions.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(${printJsValue(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(${printJsValue(column.columnType)})`)
+			}
+		}
+		const defaultColumnName = this.schemaNamingConventions.getColumnName(column.name)
+		if (defaultColumnName !== column.columnName) {
+			parts.push(`columnName(${printJsValue(column.columnName)})`)
+		}
+		if (!column.nullable) {
+			parts.push('notNull()')
+		}
+		if (column.default !== undefined) {
+			parts.push(`default(${printJsValue(column.default)})`)
+		}
+		if (column.typeAlias) {
+			parts.push(`typeAlias(${printJsValue(column.typeAlias)})`)
+		}
+
+
+		// todo: sequence
+		// todo: maybe single column unique()
+
+		return parts
+	}
+
+	private formatIdentifier(id: string): string {
+		return this.definitionNamingConventions.formatIdentifier(id)
+	}
+}
+
+
+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/DefinitionNamingConventions.ts

@@ -0,0 +1,16 @@
+export class DefinitionNamingConventions {
+	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'])
+
+	public formatIdentifier(id: string): string {
+		// todo: validate
+		return id
+	}
+
+	public roleVarName(id: string): string {
+		return this.formatIdentifier(`${id}Role`)
+	}
+
+	public variableVarName(role: string, id: string): string {
+		return this.formatIdentifier(`${id}${role.charAt(0).toUpperCase() + role.slice(1)}Variable`)
+	}
+}

package/src/definition-generator/TsDefinitionGenerator.ts

@@ -1,16 +1,11 @@
-import { Model, Schema, Writable } from '@contember/schema'
-import {
-	acceptFieldVisitor,
-	DefaultNamingConventions,
-	isInverseRelation,
-	NamingConventions,
-	NamingHelper,
-	resolveDefaultColumnType,
-} from '../model'
+import { Schema } from '@contember/schema'
+import { DefaultNamingConventions, NamingConventions } from '../model'
+import { DefinitionCodeGenerator } from './DefinitionCodeGenerator'
 
+/**
+ * @deprecated use {@link DefinitionCodeGenerator}
+ */
 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(),
@@ -18,258 +13,7 @@ export class TsDefinitionGenerator {
 	}
 
 	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`).join('')
-
-		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)})`
+		const generator = new DefinitionCodeGenerator(this.conventions)
+		return generator.generate(this.schema)
 	}
-
-	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

@@ -1 +1,4 @@
 export * from './TsDefinitionGenerator'
+export * from './AclDefinitionCodeGenerator'
+export * from './DefinitionCodeGenerator'
+export * from './DefinitionNamingConventions'

package/src/utils/printJsValue.ts

@@ -0,0 +1,62 @@
+export class Literal {
+	constructor(public readonly value: string) {
+	}
+}
+
+export type FormatterPath = ({ type: 'array' } | { type: 'object'; key: string })[]
+export type IndentDecider = (value: any, path: FormatterPath) => boolean
+
+
+export const printJsValue = (value: any, shouldIndentCb: IndentDecider = () => false, path: FormatterPath = []): string => {
+	if (value instanceof Literal) {
+		return value.value
+	}
+	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, '\\\'')}'`
+	}
+	const shouldIndent = shouldIndentCb(value, path)
+	if (!shouldIndent) {
+		shouldIndentCb = () => false
+	}
+
+	const indent = (inc: number) => '\t'.repeat(path.length + inc)
+	const nl = '\n'
+
+	if (Array.isArray(value)) {
+		return  ''
+				+ '['
+				+ value.map((it, index, arr) =>
+					(shouldIndent ? nl + indent(1) : '')
+					+ printJsValue(it, shouldIndentCb, [...path, { type: 'array' }])
+					+ (shouldIndent ? ',' : ((index + 1) < arr.length ? ', ' : '')),
+				).join('')
+				+ (shouldIndent ? nl + indent(0) : '')
+				+ ']'
+	}
+
+	return ''
+			+ '{'
+			+ (shouldIndent ? '' : ' ')
+			+ Object.entries(value).map(([key, value], index, arr) => {
+				const formattedKey = isSimpleIdentifier(key) ? key : `[${printJsValue(key)}]`
+				return ''
+					+ (shouldIndent ? nl + indent(1) : '')
+					+ formattedKey
+					+ ': '
+					+ printJsValue(value, shouldIndentCb, [...path, { type: 'object', key }])
+					+ (shouldIndent ? ',' : ((index + 1) < arr.length ? ', ' : ''))
+			}).join('')
+			+ (shouldIndent ? nl + indent(0) : ' ')
+			+ '}'
+
+}
+
+const isSimpleIdentifier = (identifier: string): boolean => {
+	return !!identifier.match(/^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/)
+}

package/src/validation/ModelValidator.ts

@@ -7,7 +7,7 @@ const RESERVED_WORDS = ['and', 'or', 'not']
 
 
 export class ModelValidator {
-	constructor(private readonly model: Model.Schema) {}
+	constructor(private readonly model: Model.Schema) { }
 
 	public validate(): ValidationError[] {
 		const errorBuilder = new ErrorBuilder([], [])
@@ -79,7 +79,7 @@ export class ModelValidator {
 		}
 	}
 
-	private validateRelation(partialEntity: Model.Entity, field: Model.AnyRelation, errors: ErrorBuilder):  void {
+	private validateRelation(partialEntity: Model.Entity, field: Model.AnyRelation, errors: ErrorBuilder): void {
 		const entityName = partialEntity.name
 		const targetEntityName = field.target
 		const targetEntity = this.model.entities[targetEntityName] || undefined
@@ -148,7 +148,7 @@ export class ModelValidator {
 				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} inverse relation is not set`)
 			}
 			if (targetField.inversedBy !== field.name) {
-				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} exepcted, ${targetField.target}::${targetField.inversedBy} given`)
+				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.inversedBy} given`)
 			}
 			if (field.type === Model.RelationType.OneHasOne && targetField.type !== Model.RelationType.OneHasOne) {
 				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} "OneHasOne" type expected, "${targetField.type}" given`)
@@ -185,7 +185,7 @@ export class ModelValidator {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} owning relation is not set`)
 				}
 				if (targetField.ownedBy !== field.name) {
-					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} exepcted, ${targetField.target}::${targetField.ownedBy} given`)
+					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.ownedBy} given`)
 				}
 				if (field.type === Model.RelationType.OneHasOne && targetField.type !== Model.RelationType.OneHasOne) {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} "OneHasOne" type expected, "${targetField.type}" given`)
@@ -259,11 +259,11 @@ export class ModelValidator {
 					}
 					aliasedTypes.set(column.typeAlias, column.type)
 				},
-				visitManyHasManyInverse: () => {},
-				visitOneHasMany: () => {},
-				visitOneHasOneInverse: () => {},
-				visitOneHasOneOwning: () => {},
-				visitManyHasOne: () => {},
+				visitManyHasManyInverse: () => { },
+				visitOneHasMany: () => { },
+				visitOneHasOneInverse: () => { },
+				visitOneHasOneOwning: () => { },
+				visitManyHasOne: () => { },
 			})
 		}
 		for (const entity of entities) {