@contember/schema-utils 1.2.1 → 1.3.0-alpha.13

package/src/definition-generator/AclDefinitionCodeGenerator.ts

@@ -0,0 +1,126 @@
+import { PredicateDefinitionProcessor } from '../acl'
+import { IndentDecider, Literal, printJsValue } from '../utils/printJsValue'
+import { Acl, Model, Schema } from '@contember/schema'
+import { DefinitionNamingConventions } from './DefinitionNamingConventions'
+
+
+const indentFirstLevel: IndentDecider = (val, path) => path.length === 0
+
+export class AclDefinitionCodeGenerator {
+
+	constructor(
+		private readonly definitionNamingConventions = new DefinitionNamingConventions(),
+	) {
+	}
+
+	public generateRoles({ acl }: { acl: Acl.Schema }): string {
+		return Object.entries(acl.roles).map(([name, values]) => this.generateRole({
+			name,
+			values,
+		})).join('')
+	}
+
+	private generateRole({ name, values }: { name: string; values: Acl.RolePermissions }): string {
+		const { variables, entities, inherits, ...other } = values
+		const roleVarName = this.definitionNamingConventions.roleVarName(name)
+		return `\nexport const ${roleVarName} = acl.createRole(${printJsValue(name)}, ${printJsValue(other)})\n`
+	}
+
+	public generateAclVariables({ acl }: { acl: Acl.Schema }): string {
+		const variablesOutput: string[] = []
+
+		Object.entries(acl.roles).map(([roleName, roleValues]) => {
+			Object.entries(roleValues.variables).map(([variableName, variableValues]) => {
+				let variableDefinition = `\nexport const ${this.definitionNamingConventions.variableVarName(roleName, variableName)} = acl.`
+				const varFormatted = printJsValue(variableName)
+				const roleVarName = this.definitionNamingConventions.roleVarName(roleName)
+
+				if (variableValues.type === Acl.VariableType.predefined) {
+					const varDefinition = printJsValue(variableValues.value)
+					variableDefinition += `createPredefinedVariable(${varFormatted}, ${varDefinition}, ${roleVarName})\n`
+				} else if (variableValues.type === Acl.VariableType.entity) {
+					const varDefinition = printJsValue(variableValues.entityName)
+					variableDefinition += `createEntityVariable(${varFormatted}, ${varDefinition}, ${roleVarName})\n`
+				} else {
+					throw new Error(`Variable type ${variableValues.type} not yet supported`)
+				}
+
+				variablesOutput.push(variableDefinition)
+			})
+		})
+
+		return variablesOutput.join('')
+	}
+
+	public generateEntityAcl({ entity, schema }: { entity: Model.Entity; schema: Schema  }): string {
+		const aclOutput: string[] = []
+		const numberOfEntityFieldsWithoutId = Object.keys(entity.fields).length - 1
+		for (const [roleName, roleDefinition] of Object.entries(schema.acl.roles)) {
+			const entityPermission = roleDefinition.entities[entity.name]
+			if (!entityPermission) {
+				continue
+			}
+			const roleVarName = this.definitionNamingConventions.roleVarName(roleName)
+			for (const [predicateName, predicateDefinition] of Object.entries(entityPermission.predicates)) {
+				const operations = this.getMatchingOperations({
+					predicate: predicateName,
+					operations: entityPermission.operations,
+					numberOfEntityFieldsWithoutId,
+				})
+				if (Object.keys(operations).length > 0) {
+					const processor = new PredicateDefinitionProcessor(schema.model)
+					const when = processor.process(entity, predicateDefinition, {
+						handleColumn: ctx => {
+							if (typeof ctx.value === 'string' && ctx.value in roleDefinition.variables) {
+								return new Literal(this.definitionNamingConventions.variableVarName(roleName, ctx.value))
+							}
+							return ctx.value
+						},
+						handleRelation: ctx => {
+							return ctx.value
+						},
+					})
+					const aclDefinition = printJsValue({ when, ...operations }, indentFirstLevel)
+					aclOutput.push(`@acl.allow(${roleVarName}, ${aclDefinition})\n`)
+				}
+			}
+			const trueOperations = this.getMatchingOperations({
+				predicate: true,
+				operations: entityPermission.operations,
+				numberOfEntityFieldsWithoutId,
+			})
+			if (Object.keys(trueOperations).length > 0) {
+				const aclDefinition = printJsValue({ ...trueOperations }, indentFirstLevel)
+				aclOutput.push(`@acl.allow(${roleVarName}, ${aclDefinition})\n`)
+			}
+		}
+
+		if (!aclOutput.length) {
+			return ''
+		}
+		return `\n${aclOutput.join('')}`
+	}
+
+	private getMatchingOperations({ operations, predicate, numberOfEntityFieldsWithoutId }: {
+		operations: Acl.EntityOperations
+		predicate: Acl.Predicate
+		numberOfEntityFieldsWithoutId: number
+	}): { read?: string[] | true; create?: string[] | boolean; update?: string[] | boolean; delete?: true } {
+		const result: ReturnType<AclDefinitionCodeGenerator['getMatchingOperations']> = {}
+		for (const op of ['read', 'create', 'update'] as const) {
+			const fields = Object.entries(operations[op] ?? {}).filter(([, it]) => it === predicate).map(([it]) => it)
+			if (fields.length === 0) {
+				continue
+			} else if (fields.length === numberOfEntityFieldsWithoutId) {
+				result[op] = true
+			} else {
+				result[op] = fields
+			}
+		}
+		if (operations.delete === predicate) {
+			result.delete = true
+		}
+
+		return result
+	}
+}

package/src/definition-generator/DefinitionCodeGenerator.ts

@@ -0,0 +1,250 @@
+import { Model, Schema, Writable } from '@contember/schema'
+import {
+	acceptFieldVisitor,
+	DefaultNamingConventions,
+	isInverseRelation,
+	NamingConventions,
+	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 fieldsList = `${constraint.fields.map(it => printJsValue(it)).join(', ')}`
+		return `@def.Unique(${fieldsList})`
+	}
+
+	private generateIndex({ entity, index }: { entity: Model.Entity; index: Model.Index }): string {
+		const fieldsList = `${index.fields.map(it => printJsValue(it)).join(', ')}`
+		return `@def.Index(${fieldsList})`
+	}
+
+
+	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`)
-
-		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'