@mikro-orm/sql 7.0.0-rc.1 → 7.0.0-rc.3

package/query/QueryBuilderHelper.js

@@ -1,6 +1,5 @@
 import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, inspect, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, Raw, QueryHelper, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
-import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
  * @internal
  */
@@ -175,13 +174,25 @@ export class QueryBuilderHelper {
             }
         }
         return {
-            prop, type, cond, ownerAlias, alias, table, schema,
-            joinColumns, inverseJoinColumns, primaryKeys,
+            prop,
+            type,
+            cond,
+            ownerAlias,
+            alias,
+            table,
+            schema,
+            joinColumns,
+            inverseJoinColumns,
+            primaryKeys,
         };
     }
     joinManyToOneReference(prop, ownerAlias, alias, type, cond = {}, schema) {
         return {
-            prop, type, cond, ownerAlias, alias,
+            prop,
+            type,
+            cond,
+            ownerAlias,
+            alias,
             table: this.getTableName(prop.targetMeta.class),
             schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta, { schema }),
             joinColumns: prop.referencedColumnNames,
@@ -194,7 +205,9 @@ export class QueryBuilderHelper {
         const pivotMeta = this.metadata.find(prop.pivotEntity);
         const ret = {
             [`${ownerAlias}.${prop.name}#${pivotAlias}`]: {
-                prop, type, ownerAlias,
+                prop,
+                type,
+                ownerAlias,
                 alias: pivotAlias,
                 inverseAlias: alias,
                 joinColumns: prop.joinColumns,
@@ -256,7 +269,9 @@ export class QueryBuilderHelper {
                 conditions.push(`${left} = ${this.platform.quoteIdentifier(right)}`);
             });
         }
-        if (join.prop.targetMeta?.root.inheritanceType === 'sti' && join.prop.targetMeta?.discriminatorValue && !join.path?.endsWith('[pivot]')) {
+        if (join.prop.targetMeta?.root.inheritanceType === 'sti' &&
+            join.prop.targetMeta?.discriminatorValue &&
+            !join.path?.endsWith('[pivot]')) {
             const typeProperty = join.prop.targetMeta.root.discriminatorColumn;
             const alias = join.inverseAlias ?? join.alias;
             join.cond[`${alias}.${typeProperty}`] = join.prop.targetMeta.discriminatorValue;
@@ -455,7 +470,7 @@ export class QueryBuilderHelper {
         // grouped condition for one field, e.g. `{ age: { $gte: 10, $lt: 50 } }`
         if (size > 1) {
             const subCondition = Object.entries(value).map(([subKey, subValue]) => {
-                return ({ [key]: { [subKey]: subValue } });
+                return { [key]: { [subKey]: subValue } };
             });
             for (const sub of subCondition) {
                 this.append(() => this._appendQueryCondition(type, sub, '$and'), parts, params);
@@ -521,8 +536,8 @@ export class QueryBuilderHelper {
         else if (['$in', '$nin'].includes(op) && Array.isArray(value[op]) && value[op].length === 0) {
             parts.push(`1 = ${op === '$in' ? 0 : 1}`);
         }
-        else if (value[op] instanceof Raw || value[op] instanceof NativeQueryBuilder) {
-            const query = value[op] instanceof NativeQueryBuilder ? value[op].toRaw() : value[op];
+        else if (value[op] instanceof Raw || typeof value[op]?.toRaw === 'function') {
+            const query = value[op] instanceof Raw ? value[op] : value[op].toRaw();
             const mappedKey = this.mapper(key, type, query, null);
             let sql = query.sql;
             if (['$in', '$nin'].includes(op)) {
@@ -549,7 +564,11 @@ export class QueryBuilderHelper {
                 return `(${tmp.join(', ')})`;
             }
             if (prop?.customType instanceof ArrayType) {
-                const item = prop.customType.convertToDatabaseValue(value, this.platform, { fromQuery: true, key, mode: 'query' });
+                const item = prop.customType.convertToDatabaseValue(value, this.platform, {
+                    fromQuery: true,
+                    key,
+                    mode: 'query',
+                });
                 params.push(item);
             }
             else {
@@ -629,11 +648,14 @@ export class QueryBuilderHelper {
                 const noPrefix = (prop?.persist === false && !prop.formula && !prop.embedded) || Raw.isKnownFragment(f);
                 const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* v8 ignore next */
-                const rawColumn = typeof column === 'string' ? column.split('.').map(e => this.platform.quoteIdentifier(e)).join('.') : column;
+                const rawColumn = typeof column === 'string'
+                    ? column
+                        .split('.')
+                        .map(e => this.platform.quoteIdentifier(e))
+                        .join('.')
+                    : column;
                 const customOrder = prop?.customOrder;
-                let colPart = customOrder
-                    ? this.platform.generateCustomOrder(rawColumn, customOrder)
-                    : rawColumn;
+                let colPart = customOrder ? this.platform.generateCustomOrder(rawColumn, customOrder) : rawColumn;
                 if (isRaw(colPart)) {
                     colPart = this.platform.formatQuery(colPart.sql, colPart.params);
                 }
@@ -672,7 +694,9 @@ export class QueryBuilderHelper {
                 const fields = returningProps.flatMap((prop) => {
                     if (prop.hasConvertToJSValueSQL) {
                         const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                        const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) + ' as ' + this.platform.quoteIdentifier(prop.fieldNames[0]);
+                        const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) +
+                            ' as ' +
+                            this.platform.quoteIdentifier(prop.fieldNames[0]);
                         return [raw(sql)];
                     }
                     return prop.fieldNames;
@@ -770,7 +794,9 @@ export class QueryBuilderHelper {
             // skip nesting parens if the value is simple = scalar or object without operators or with only single key, being the operator
             const keys = Utils.getObjectQueryKeys(sub);
             const val = sub[keys[0]];
-            const simple = !Utils.isPlainObject(val) || Utils.getObjectKeysSize(val) === 1 || Object.keys(val).every(k => !Utils.isOperator(k));
+            const simple = !Utils.isPlainObject(val) ||
+                Utils.getObjectKeysSize(val) === 1 ||
+                Object.keys(val).every(k => !Utils.isOperator(k));
             if (keys.length === 1 && simple) {
                 this.append(() => this._appendQueryCondition(type, sub, operator), parts, params);
                 continue;
@@ -804,7 +830,11 @@ export class QueryBuilderHelper {
     }
     getProperty(field, alias) {
         const entityName = this.aliasMap[alias]?.entityName || this.entityName;
-        const meta = this.metadata.get(entityName);
+        const meta = this.metadata.find(entityName);
+        // raw table name (e.g. CTE) — no metadata available
+        if (!meta) {
+            return undefined;
+        }
         // check if `alias` is not matching an embedded property name instead of alias, e.g. `address.city`
         if (alias) {
             const prop = meta.properties[alias];

package/query/ScalarCriteriaNode.js

@@ -7,7 +7,8 @@ import { QueryBuilder } from './QueryBuilder.js';
  */
 export class ScalarCriteriaNode extends CriteriaNode {
     process(qb, options) {
-        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const matchPopulateJoins = options?.matchPopulateJoins ||
+            (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
         const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...options, matchPopulateJoins });
         if (this.shouldJoin(qb, nestedAlias)) {
             const path = this.getPath();
@@ -22,7 +23,7 @@ export class ScalarCriteriaNode extends CriteriaNode {
             }
         }
         if (this.payload instanceof QueryBuilder) {
-            return this.payload.getNativeQuery().toRaw();
+            return this.payload.toRaw();
         }
         if (this.payload && typeof this.payload === 'object') {
             const keys = Object.keys(this.payload).filter(key => ARRAY_OPERATORS.includes(key) && Array.isArray(this.payload[key]));
@@ -36,14 +37,20 @@ export class ScalarCriteriaNode extends CriteriaNode {
         return this.shouldJoin(qb, alias);
     }
     shouldJoin(qb, nestedAlias) {
-        if (!this.parent || !this.prop || (nestedAlias && [QueryType.SELECT, QueryType.COUNT].includes(qb.type ?? QueryType.SELECT))) {
+        if (!this.parent ||
+            !this.prop ||
+            (nestedAlias && [QueryType.SELECT, QueryType.COUNT].includes(qb.type ?? QueryType.SELECT))) {
             return false;
         }
         switch (this.prop.kind) {
-            case ReferenceKind.ONE_TO_MANY: return true;
-            case ReferenceKind.MANY_TO_MANY: return true;
-            case ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
-            default: return false; // SCALAR, MANY_TO_ONE
+            case ReferenceKind.ONE_TO_MANY:
+                return true;
+            case ReferenceKind.MANY_TO_MANY:
+                return true;
+            case ReferenceKind.ONE_TO_ONE:
+                return !this.prop.owner;
+            default:
+                return false; // SCALAR, MANY_TO_ONE
         }
     }
 }

package/query/raw.js

@@ -1,4 +1,4 @@
-import { raw as raw_, Utils } from '@mikro-orm/core';
+import { raw as raw_, Utils, } from '@mikro-orm/core';
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
  * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value

package/schema/DatabaseSchema.js

@@ -81,8 +81,11 @@ export class DatabaseSchema {
         const parts = config.get('migrations').tableName.split('.');
         const migrationsTableName = parts[1] ?? parts[0];
         const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
-        const tables = allTables.filter(t => this.isTableNameAllowed(t.table_name, takeTables, skipTables) && (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
-        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
+        const tables = allTables.filter(t => this.isTableNameAllowed(t.table_name, takeTables, skipTables) &&
+            (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
+        await platform
+            .getSchemaHelper()
+            .loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
         // Load views from database
         await platform.getSchemaHelper().loadViews(schema, connection);
         // Load materialized views (PostgreSQL only)
@@ -140,9 +143,7 @@ export class DatabaseSchema {
             table.comment = meta.comment;
             // For TPT child entities, only use ownProps (properties defined in this entity only)
             // For all other entities (including TPT root), use all props
-            const propsToProcess = meta.inheritanceType === 'tpt' && meta.tptParent && meta.ownProps
-                ? meta.ownProps
-                : meta.props;
+            const propsToProcess = meta.inheritanceType === 'tpt' && meta.tptParent && meta.ownProps ? meta.ownProps : meta.props;
             for (const prop of propsToProcess) {
                 if (!this.shouldHaveColumn(meta, prop, skipColumns)) {
                     continue;
@@ -177,7 +178,9 @@ export class DatabaseSchema {
             table.addIndex(meta, { properties: pkPropsForIndex.map(prop => prop.name) }, 'primary');
             for (const check of meta.checks) {
                 const columnName = check.property ? meta.properties[check.property].fieldNames[0] : undefined;
-                const expression = isRaw(check.expression) ? platform.formatQuery(check.expression.sql, check.expression.params) : check.expression;
+                const expression = isRaw(check.expression)
+                    ? platform.formatQuery(check.expression.sql, check.expression.params)
+                    : check.expression;
                 table.addCheck({
                     name: check.name,
                     expression,
@@ -229,7 +232,7 @@ export class DatabaseSchema {
         const pkColumnNames = meta.primaryKeys.flatMap(pk => meta.properties[pk].fieldNames);
         const parentPkColumnNames = parent.primaryKeys.flatMap(pk => parent.properties[pk].fieldNames);
         // Determine the parent table name with schema
-        const parentSchema = parent.schema === '*' ? undefined : parent.schema ?? config.get('schema', platform.getDefaultSchemaName());
+        const parentSchema = parent.schema === '*' ? undefined : (parent.schema ?? config.get('schema', platform.getDefaultSchemaName()));
         const parentTableName = parentSchema ? `${parentSchema}.${parent.tableName}` : parent.tableName;
         // Create FK constraint name
         const constraintName = platform.getIndexName(table.name, pkColumnNames, 'foreign');
@@ -284,7 +287,8 @@ export class DatabaseSchema {
         if (rootProp.kind === ReferenceKind.EMBEDDED) {
             return prop === rootProp || !rootProp.object;
         }
-        return [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner);
+        return ([ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE].includes(prop.kind) ||
+            (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner));
     }
     toJSON() {
         const { platform, namespaces, ...rest } = this;
@@ -293,19 +297,21 @@ export class DatabaseSchema {
     prune(schema, wildcardSchemaTables) {
         const hasWildcardSchema = wildcardSchemaTables.length > 0;
         this.tables = this.tables.filter(table => {
-            return (!schema && !hasWildcardSchema) // no schema specified and we don't have any multi-schema entity
-                || table.schema === schema // specified schema matches the table's one
-                || (!schema && !wildcardSchemaTables.includes(table.name)); // no schema specified and the table has fixed one provided
+            return ((!schema && !hasWildcardSchema) || // no schema specified and we don't have any multi-schema entity
+                table.schema === schema || // specified schema matches the table's one
+                (!schema && !wildcardSchemaTables.includes(table.name))); // no schema specified and the table has fixed one provided
         });
         this.views = this.views.filter(view => {
             /* v8 ignore next */
-            return (!schema && !hasWildcardSchema)
-                || view.schema === schema
-                || (!schema && !wildcardSchemaTables.includes(view.name));
+            return ((!schema && !hasWildcardSchema) ||
+                view.schema === schema ||
+                (!schema && !wildcardSchemaTables.includes(view.name)));
         });
         // remove namespaces of ignored tables and views
         for (const ns of this.namespaces) {
-            if (!this.tables.some(t => t.schema === ns) && !this.views.some(v => v.schema === ns) && !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
+            if (!this.tables.some(t => t.schema === ns) &&
+                !this.views.some(v => v.schema === ns) &&
+                !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
                 this.namespaces.delete(ns);
             }
         }

package/schema/DatabaseTable.js

@@ -80,10 +80,13 @@ export class DatabaseTable {
             this.columns[field] = {
                 name: prop.fieldNames[idx],
                 type: prop.columnTypes[idx],
-                generated: prop.generated instanceof RawQueryFragment ? this.platform.formatQuery(prop.generated.sql, prop.generated.params) : prop.generated,
+                generated: prop.generated instanceof RawQueryFragment
+                    ? this.platform.formatQuery(prop.generated.sql, prop.generated.params)
+                    : prop.generated,
                 mappedType,
                 unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
-                autoincrement: prop.autoincrement ?? (primary && prop.kind === ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType)),
+                autoincrement: prop.autoincrement ??
+                    (primary && prop.kind === ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType)),
                 primary,
                 nullable: this.columns[field]?.nullable ?? !!prop.nullable,
                 nativeEnumName: prop.nativeEnumName,
@@ -105,7 +108,9 @@ export class DatabaseTable {
         });
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.polymorphic) {
             const constraintName = this.getIndexName(prop.foreignKeyName ?? true, prop.fieldNames, 'foreign');
-            let schema = prop.targetMeta.root.schema === '*' ? this.schema : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
+            let schema = prop.targetMeta.root.schema === '*'
+                ? this.schema
+                : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
             if (prop.referencedTableName.includes('.')) {
                 schema = undefined;
             }
@@ -154,19 +159,20 @@ export class DatabaseTable {
         return this.platform.getIndexName(this.name, columnNames, type);
     }
     getEntityDeclaration(namingStrategy, schemaHelper, scalarPropertiesForRelations) {
-        const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames, } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
+        const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
         const name = namingStrategy.getEntityName(this.name, this.schema);
         const schema = new EntitySchema({ name, collection: this.name, schema: this.schema, comment: this.comment });
         const compositeFkIndexes = {};
         const compositeFkUniques = {};
-        const potentiallyUnmappedIndexes = this.indexes.filter(index => !index.primary // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
-            && (( // Non-trivial non-composite indexes will be declared at the entity's metadata, though later outputted in the property
-            index.columnNames.length > 1 // All composite indexes are to be mapped to entity decorators or FK props.
-                || skippedColumnNames.includes(index.columnNames[0]) // Non-composite indexes for skipped columns are to be mapped as entity decorators.
-                || index.deferMode || index.expression || !(index.columnNames[0] in columnFks)) // Trivial non-composite indexes for scalar props are to be mapped to the column.
-            )
+        const potentiallyUnmappedIndexes = this.indexes.filter(index => !index.primary && // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
+            // Non-trivial non-composite indexes will be declared at the entity's metadata, though later outputted in the property
+            (index.columnNames.length > 1 || // All composite indexes are to be mapped to entity decorators or FK props.
+                skippedColumnNames.includes(index.columnNames[0]) || // Non-composite indexes for skipped columns are to be mapped as entity decorators.
+                index.deferMode ||
+                index.expression ||
+                !(index.columnNames[0] in columnFks)) && // Trivial non-composite indexes for scalar props are to be mapped to the column.
             // ignore indexes that don't have all column names (this can happen in sqlite where there is no way to infer this for expressions)
-            && !(index.columnNames.some(col => !col) && !index.expression));
+            !(index.columnNames.some(col => !col) && !index.expression));
         // Helper to map column name to property name
         const columnToPropertyName = (colName) => this.getPropertyName(namingStrategy, colName);
         for (const index of potentiallyUnmappedIndexes) {
@@ -198,8 +204,13 @@ export class DatabaseTable {
                 }
             }
             // An index is trivial if it has no special options that require entity-level declaration
-            const hasAdvancedOptions = index.columns?.length || index.include?.length || index.fillFactor ||
-                index.type || index.invisible || index.disabled || index.clustered;
+            const hasAdvancedOptions = index.columns?.length ||
+                index.include?.length ||
+                index.fillFactor ||
+                index.type ||
+                index.invisible ||
+                index.disabled ||
+                index.clustered;
             const isTrivial = !index.deferMode && !index.expression && !hasAdvancedOptions;
             if (isTrivial) {
                 // Index is for FK. Map to the FK prop and move on.
@@ -213,7 +224,8 @@ export class DatabaseTable {
                     }
                 }
             }
-            const properties = ret.properties ?? this.getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy);
+            const properties = ret.properties ??
+                this.getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy);
             // If there is a column that cannot be unambiguously mapped to a prop, render an expression.
             if (typeof properties === 'undefined') {
                 ret.expression ??= schemaHelper.getCreateIndexSQL(this.name, index);
@@ -237,7 +249,7 @@ export class DatabaseTable {
             }
             schema.addIndex(ret);
         }
-        const addedStandaloneFkPropsBasedOnColumn = new Set;
+        const addedStandaloneFkPropsBasedOnColumn = new Set();
         const nonSkippedColumns = this.getColumns().filter(column => !skippedColumnNames.includes(column.name));
         for (const column of nonSkippedColumns) {
             const columnName = column.name;
@@ -259,10 +271,10 @@ export class DatabaseTable {
             schema.addProperty(prop.name, prop.type, prop);
         }
         const meta = schema.init().meta;
-        const oneToOneCandidateProperties = meta.relations
-            .filter(prop => prop.primary && prop.kind === ReferenceKind.MANY_TO_ONE);
-        if (oneToOneCandidateProperties.length === 1
-            && oneToOneCandidateProperties[0].fieldNames.length === (new Set(meta.getPrimaryProps().flatMap(prop => prop.fieldNames))).size) {
+        const oneToOneCandidateProperties = meta.relations.filter(prop => prop.primary && prop.kind === ReferenceKind.MANY_TO_ONE);
+        if (oneToOneCandidateProperties.length === 1 &&
+            oneToOneCandidateProperties[0].fieldNames.length ===
+                new Set(meta.getPrimaryProps().flatMap(prop => prop.fieldNames)).size) {
             oneToOneCandidateProperties[0].kind = ReferenceKind.ONE_TO_ONE;
         }
         return meta;
@@ -277,7 +289,8 @@ export class DatabaseTable {
         const standaloneFksBasedOnColumnNames = new Map();
         for (const currentFk of fks) {
             const fkIndex = this.findFkIndex(currentFk);
-            if (currentFk.columnNames.length === 1 && !fks.some(fk => fk !== currentFk && fk.columnNames.length === 1 && currentFk.columnNames[0] === fk.columnNames[0])) {
+            if (currentFk.columnNames.length === 1 &&
+                !fks.some(fk => fk !== currentFk && fk.columnNames.length === 1 && currentFk.columnNames[0] === fk.columnNames[0])) {
                 // Non-composite FK is the only possible one for a column. Render the column with it.
                 const columnName = currentFk.columnNames[0];
                 columnFks[columnName] ??= [];
@@ -316,7 +329,10 @@ export class DatabaseTable {
             if (nullableColumnsInFk.length > 0) {
                 nullableForeignKeys.add(currentFk);
             }
-            if (specificColumnNames.length === 1 && ((nullableColumnsInFk.length === currentFk.columnNames.length || nullableColumnsInFk.length === 0) || (nullableColumnsInFk.length === 1 && nullableColumnsInFk[0] === specificColumnNames[0]))) {
+            if (specificColumnNames.length === 1 &&
+                (nullableColumnsInFk.length === currentFk.columnNames.length ||
+                    nullableColumnsInFk.length === 0 ||
+                    (nullableColumnsInFk.length === 1 && nullableColumnsInFk[0] === specificColumnNames[0]))) {
                 // Composite FK has exactly one column which is not used in any other FK.
                 // The FK also doesn't have a mix of nullable and non-nullable columns,
                 // or its only nullable column is this very one.
@@ -391,14 +407,16 @@ export class DatabaseTable {
             // But also does not skip if the column is not nullable, and yet all involved FKs are nullable,
             // or if one or more FKs involved has multiple nullable columns.
             smart: (column) => {
-                return columnsInFks.includes(column.name)
-                    && !fksOnColumnProps.has(column.name)
-                    && (column.nullable
+                return (columnsInFks.includes(column.name) &&
+                    !fksOnColumnProps.has(column.name) &&
+                    (column.nullable
                         ? columnFks[column.name].some(fk => !fk.columnNames.some(fkColumnName => fkColumnName !== column.name && this.getColumn(fkColumnName)?.nullable))
-                        : columnFks[column.name].some(fk => !nullableForeignKeys.has(fk)));
+                        : columnFks[column.name].some(fk => !nullableForeignKeys.has(fk))));
             },
         };
-        const skippedColumnNames = this.getColumns().filter(skippingHandlers[scalarPropertiesForRelations]).map(column => column.name);
+        const skippedColumnNames = this.getColumns()
+            .filter(skippingHandlers[scalarPropertiesForRelations])
+            .map(column => column.name);
         // Check standalone FKs named after columns for potential conflicts among themselves.
         // This typically happens when two standalone FKs named after a column resolve to the same prop name
         // because the respective columns include the referenced table in the name.
@@ -439,7 +457,8 @@ export class DatabaseTable {
     findFkIndex(currentFk) {
         const fkColumnsLength = currentFk.columnNames.length;
         const possibleIndexes = this.indexes.filter(index => {
-            return index.columnNames.length === fkColumnsLength && !currentFk.columnNames.some((columnName, i) => index.columnNames[i] !== columnName);
+            return (index.columnNames.length === fkColumnsLength &&
+                !currentFk.columnNames.some((columnName, i) => index.columnNames[i] !== columnName));
         });
         possibleIndexes.sort((a, b) => {
             if (a.primary !== b.primary) {
@@ -502,7 +521,8 @@ export class DatabaseTable {
         return Array.from(propBaseNames).map(baseName => this.getPropertyName(namingStrategy, baseName, fksOnColumnProps.get(baseName)));
     }
     getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName) {
-        if (columnName && this.getPropertyName(namingStrategy, columnName, currentFk) !== this.getPropertyName(namingStrategy, columnName)) {
+        if (columnName &&
+            this.getPropertyName(namingStrategy, columnName, currentFk) !== this.getPropertyName(namingStrategy, columnName)) {
             // The eligible scalar column name is different from the name of the FK prop of the same column.
             // Both can be safely rendered.
             // Use the column name as a base for the FK prop.
@@ -538,7 +558,9 @@ export class DatabaseTable {
      */
     getShortestName(skipDefaultSchema = true) {
         const defaultSchema = this.platform.getDefaultSchemaName();
-        if (!this.schema || this.name.startsWith(defaultSchema + '.') || (this.schema === defaultSchema && skipDefaultSchema)) {
+        if (!this.schema ||
+            this.name.startsWith(defaultSchema + '.') ||
+            (this.schema === defaultSchema && skipDefaultSchema)) {
             return this.name;
         }
         return `${this.schema}.${this.name}`;
@@ -569,7 +591,7 @@ export class DatabaseTable {
     }
     getForeignKeyDeclaration(fk, namingStrategy, schemaHelper, fkIndex, nullable, propNameBase, fksOnColumnProps) {
         const prop = this.getPropertyName(namingStrategy, propNameBase, fk);
-        const kind = (fkIndex?.unique && !fkIndex.primary) ? this.getReferenceKind(fk, fkIndex) : this.getReferenceKind(fk);
+        const kind = fkIndex?.unique && !fkIndex.primary ? this.getReferenceKind(fk, fkIndex) : this.getReferenceKind(fk);
         const runtimeType = this.getPropertyTypeForForeignKey(namingStrategy, fk);
         const fkOptions = {};
         fkOptions.fieldNames = fk.columnNames;
@@ -584,8 +606,8 @@ export class DatabaseTable {
             const column = this.getColumn(fk.columnNames[0]);
             const defaultRaw = this.getPropertyDefaultValue(schemaHelper, column, column.type, true);
             const defaultTs = this.getPropertyDefaultValue(schemaHelper, column, column.type);
-            columnOptions.default = (defaultRaw !== defaultTs || defaultRaw === '') ? defaultTs : undefined;
-            columnOptions.defaultRaw = (column.nullable && defaultRaw === 'null') ? undefined : defaultRaw;
+            columnOptions.default = defaultRaw !== defaultTs || defaultRaw === '' ? defaultTs : undefined;
+            columnOptions.defaultRaw = column.nullable && defaultRaw === 'null' ? undefined : defaultRaw;
             columnOptions.optional = typeof column.generated !== 'undefined' || defaultRaw !== 'null';
             columnOptions.generated = column.generated;
             columnOptions.nullable = column.nullable;
@@ -607,25 +629,29 @@ export class DatabaseTable {
             nullable,
             primary: fkIndex?.primary || !fk.columnNames.some(columnName => !this.getPrimaryKey()?.columnNames.includes(columnName)),
             index: !fkIndex?.unique ? fkIndex?.keyName : undefined,
-            unique: (fkIndex?.unique && !fkIndex.primary) ? fkIndex.keyName : undefined,
+            unique: fkIndex?.unique && !fkIndex.primary ? fkIndex.keyName : undefined,
             ...fkOptions,
         };
     }
     getPropertyDeclaration(column, namingStrategy, schemaHelper, compositeFkIndexes, compositeFkUniques, columnFks, fk) {
         const prop = this.getPropertyName(namingStrategy, column.name, fk);
         const persist = !(column.name in columnFks && typeof fk === 'undefined');
-        const index = compositeFkIndexes[prop] || this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
-        const unique = compositeFkUniques[prop] || this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
+        const index = compositeFkIndexes[prop] ||
+            this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
+        const unique = compositeFkUniques[prop] ||
+            this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
         const kind = this.getReferenceKind(fk, unique);
         const runtimeType = this.getPropertyTypeForColumn(namingStrategy, column, fk);
-        const type = fk ? runtimeType : (Utils.keys(t).find(k => {
-            const typeInCoreMap = this.platform.getMappedType(k);
-            return (typeInCoreMap !== Type.getType(UnknownType) || k === 'unknown') && typeInCoreMap === column.mappedType;
-        }) ?? runtimeType);
-        const ignoreSchemaChanges = (type === 'unknown' && column.length) ? (column.extra ? ['type', 'extra'] : ['type']) : undefined;
+        const type = fk
+            ? runtimeType
+            : (Utils.keys(t).find(k => {
+                const typeInCoreMap = this.platform.getMappedType(k);
+                return ((typeInCoreMap !== Type.getType(UnknownType) || k === 'unknown') && typeInCoreMap === column.mappedType);
+            }) ?? runtimeType);
+        const ignoreSchemaChanges = type === 'unknown' && column.length ? (column.extra ? ['type', 'extra'] : ['type']) : undefined;
         const defaultRaw = this.getPropertyDefaultValue(schemaHelper, column, runtimeType, true);
         const defaultParsed = this.getPropertyDefaultValue(schemaHelper, column, runtimeType);
-        const defaultTs = (defaultRaw !== defaultParsed || defaultParsed === '') ? defaultParsed : undefined;
+        const defaultTs = defaultRaw !== defaultParsed || defaultParsed === '' ? defaultParsed : undefined;
         const fkOptions = {};
         if (fk) {
             fkOptions.fieldNames = fk.columnNames;
@@ -646,7 +672,7 @@ export class DatabaseTable {
             optional: defaultRaw !== 'null' || defaultTs != null || typeof column.generated !== 'undefined',
             columnType: column.type,
             default: defaultTs,
-            defaultRaw: (column.nullable && defaultRaw === 'null') ? undefined : defaultRaw,
+            defaultRaw: column.nullable && defaultRaw === 'null' ? undefined : defaultRaw,
             nullable: column.nullable,
             primary: column.primary && persist,
             autoincrement: column.autoincrement,
@@ -720,7 +746,7 @@ export class DatabaseTable {
         const defaultValue = column.default ?? 'null';
         const val = schemaHelper.normalizeDefaultValue(defaultValue, column.length);
         if (val === 'null') {
-            return raw ? 'null' : (column.nullable ? null : undefined);
+            return raw ? 'null' : column.nullable ? null : undefined;
         }
         if (propType === 'boolean' && !raw) {
             return !['0', 'false', 'f', 'n', 'no', 'off'].includes('' + column.default);
@@ -752,7 +778,9 @@ export class DatabaseTable {
     }
     addIndex(meta, index, type) {
         // If columns are specified but properties are not, derive properties from column names
-        if (index.columns?.length && !index.expression && (!index.properties || Utils.asArray(index.properties).length === 0)) {
+        if (index.columns?.length &&
+            !index.expression &&
+            (!index.properties || Utils.asArray(index.properties).length === 0)) {
             index = { ...index, properties: index.columns.map(c => c.name) };
         }
         const properties = Utils.unique(Utils.flatten(Utils.asArray(index.properties).map(prop => {
@@ -787,13 +815,15 @@ export class DatabaseTable {
         }
         const name = this.getIndexName(index.name, properties, type);
         // Process include columns (map property names to field names)
-        const includeColumns = index.include ? Utils.unique(Utils.flatten(Utils.asArray(index.include).map(prop => {
-            if (meta.properties[prop]) {
-                return meta.properties[prop].fieldNames;
-            }
-            /* v8 ignore next */
-            return [prop];
-        }))) : undefined;
+        const includeColumns = index.include
+            ? Utils.unique(Utils.flatten(Utils.asArray(index.include).map(prop => {
+                if (meta.properties[prop]) {
+                    return meta.properties[prop].fieldNames;
+                }
+                /* v8 ignore next */
+                return [prop];
+            })))
+            : undefined;
         // Process columns with advanced options (map property names to field names)
         const columns = index.columns?.map(col => {
             const fieldName = meta.properties[col.name]?.fieldNames[0] ?? col.name;
@@ -843,9 +873,39 @@ export class DatabaseTable {
     toJSON() {
         const { platform, columns, ...rest } = this;
         const columnsMapped = Utils.keys(columns).reduce((o, col) => {
-            const { mappedType, ...restCol } = columns[col];
-            o[col] = restCol;
-            o[col].mappedType = Utils.keys(t).find(k => t[k] === mappedType.constructor);
+            const c = columns[col];
+            const normalized = {
+                name: c.name,
+                type: c.type,
+                unsigned: !!c.unsigned,
+                autoincrement: !!c.autoincrement,
+                primary: !!c.primary,
+                nullable: !!c.nullable,
+                unique: !!c.unique,
+                length: c.length ?? null,
+                precision: c.precision ?? null,
+                scale: c.scale ?? null,
+                default: c.default ?? null,
+                comment: c.comment ?? null,
+                enumItems: c.enumItems ?? [],
+                mappedType: Utils.keys(t).find(k => t[k] === c.mappedType.constructor),
+            };
+            if (c.generated) {
+                normalized.generated = c.generated;
+            }
+            if (c.nativeEnumName) {
+                normalized.nativeEnumName = c.nativeEnumName;
+            }
+            if (c.extra) {
+                normalized.extra = c.extra;
+            }
+            if (c.ignoreSchemaChanges) {
+                normalized.ignoreSchemaChanges = c.ignoreSchemaChanges;
+            }
+            if (c.defaultConstraint) {
+                normalized.defaultConstraint = c.defaultConstraint;
+            }
+            o[col] = normalized;
             return o;
         }, {});
         return { columns: columnsMapped, ...rest };