@mikro-orm/knex 7.0.0-dev.1 → 7.0.0-dev.2

package/schema/DatabaseSchema.d.ts

@@ -1,7 +1,7 @@
 import { type Configuration, type Dictionary, type EntityMetadata } from '@mikro-orm/core';
-import { DatabaseTable } from './DatabaseTable';
-import type { AbstractSqlConnection } from '../AbstractSqlConnection';
-import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
+import { DatabaseTable } from './DatabaseTable.js';
+import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
  */

package/schema/DatabaseSchema.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseSchema = void 0;
-const core_1 = require("@mikro-orm/core");
-const DatabaseTable_1 = require("./DatabaseTable");
+import { ReferenceKind } from '@mikro-orm/core';
+import { DatabaseTable } from './DatabaseTable.js';
 /**
  * @internal
  */
-class DatabaseSchema {
+export class DatabaseSchema {
     platform;
     name;
     tables = [];
@@ -18,7 +15,7 @@ class DatabaseSchema {
     }
     addTable(name, schema, comment) {
         const namespaceName = schema ?? this.name;
-        const table = new DatabaseTable_1.DatabaseTable(this.platform, name, namespaceName);
+        const table = new DatabaseTable(this.platform, name, namespaceName);
         table.nativeEnums = this.nativeEnums;
         table.comment = comment;
         this.tables.push(table);
@@ -136,15 +133,15 @@ class DatabaseSchema {
         if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {
             return false;
         }
-        if (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.object) {
+        if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
             return true;
         }
         const getRootProperty = (prop) => prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop;
         const rootProp = getRootProperty(prop);
-        if (rootProp.kind === core_1.ReferenceKind.EMBEDDED) {
+        if (rootProp.kind === ReferenceKind.EMBEDDED) {
             return prop === rootProp || !rootProp.object;
         }
-        return [core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === core_1.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;
@@ -165,4 +162,3 @@ class DatabaseSchema {
         }
     }
 }
-exports.DatabaseSchema = DatabaseSchema;

package/schema/DatabaseTable.d.ts

@@ -1,7 +1,7 @@
 import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from '@mikro-orm/core';
-import type { SchemaHelper } from './SchemaHelper';
-import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings';
-import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
+import type { SchemaHelper } from './SchemaHelper.js';
+import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
  */

package/schema/DatabaseTable.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseTable = void 0;
-const core_1 = require("@mikro-orm/core");
+import { Cascade, DecimalType, EntitySchema, ReferenceKind, t, Type, UnknownType, Utils, } from '@mikro-orm/core';
 /**
  * @internal
  */
-class DatabaseTable {
+export class DatabaseTable {
     platform;
     name;
     schema;
@@ -36,7 +33,7 @@ class DatabaseTable {
         delete this.columns[name];
     }
     getIndexes() {
-        return core_1.Utils.removeDuplicates(this.indexes);
+        return Utils.removeDuplicates(this.indexes);
     }
     getChecks() {
         return this.checks;
@@ -64,9 +61,9 @@ class DatabaseTable {
         prop.fieldNames?.forEach((field, idx) => {
             const type = prop.enum ? 'enum' : prop.columnTypes[idx];
             const mappedType = this.platform.getMappedType(type);
-            if (mappedType instanceof core_1.DecimalType) {
+            if (mappedType instanceof DecimalType) {
                 const match = prop.columnTypes[idx].match(/\w+\((\d+), ?(\d+)\)/);
-                /* istanbul ignore else */
+                /* v8 ignore next 5 */
                 if (match) {
                     prop.precision ??= +match[1];
                     prop.scale ??= +match[2];
@@ -86,7 +83,7 @@ class DatabaseTable {
                 generated: prop.generated,
                 mappedType,
                 unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
-                autoincrement: prop.autoincrement ?? (primary && prop.kind === core_1.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,
@@ -94,7 +91,7 @@ class DatabaseTable {
                 precision: prop.precision,
                 scale: prop.scale,
                 default: prop.defaultRaw,
-                enumItems: prop.nativeEnumName || prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
+                enumItems: prop.nativeEnumName || prop.items?.every(Utils.isString) ? prop.items : undefined,
                 comment: prop.comment,
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
@@ -103,7 +100,7 @@ class DatabaseTable {
             const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
             this.columns[field].default = defaultValue;
         });
-        if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             const constraintName = this.getIndexName(true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.root.schema === '*' ? this.schema : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
             if (prop.referencedTableName.includes('.')) {
@@ -116,14 +113,14 @@ class DatabaseTable {
                 referencedColumnNames: prop.referencedColumnNames,
                 referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
             };
-            const cascade = prop.cascade.includes(core_1.Cascade.REMOVE) || prop.cascade.includes(core_1.Cascade.ALL);
+            const cascade = prop.cascade.includes(Cascade.REMOVE) || prop.cascade.includes(Cascade.ALL);
             if (prop.deleteRule || cascade || prop.nullable) {
                 this.foreignKeys[constraintName].deleteRule = prop.deleteRule || (cascade ? 'cascade' : 'set null');
             }
             if (prop.updateRule) {
                 this.foreignKeys[constraintName].updateRule = prop.updateRule || 'cascade';
             }
-            if ((prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL))) {
+            if ((prop.cascade.includes(Cascade.PERSIST) || prop.cascade.includes(Cascade.ALL))) {
                 const hasCascadePath = Object.values(this.foreignKeys).some(fk => {
                     return fk.constraintName !== constraintName
                         && ((fk.updateRule && fk.updateRule !== 'no action') || (fk.deleteRule && fk.deleteRule !== 'no action'))
@@ -160,7 +157,7 @@ class DatabaseTable {
         }
     }
     getIndexName(value, columnNames, type) {
-        if (core_1.Utils.isString(value)) {
+        if (Utils.isString(value)) {
             return value;
         }
         return this.platform.getIndexName(this.name, columnNames, type);
@@ -168,14 +165,14 @@ class DatabaseTable {
     getEntityDeclaration(namingStrategy, schemaHelper, scalarPropertiesForRelations) {
         const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames, } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
         const name = namingStrategy.getEntityName(this.name, this.schema);
-        const schema = new core_1.EntitySchema({ name, collection: this.name, schema: this.schema, comment: this.comment });
+        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.
-            && (index.columnNames.length > 1 // All composite indexes are to be mapped to entity decorators or FK props.
+            && (( // 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 // Non-trivial non-composite indexes will be declared at the entity's metadata, though later outputted in the property
-                || !(index.columnNames[0] in columnFks) // Trivial non-composite indexes for scalar props are to be mapped to the column.
+                || 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));
@@ -245,10 +242,10 @@ class DatabaseTable {
         }
         const meta = schema.init().meta;
         const oneToOneCandidateProperties = meta.relations
-            .filter(prop => prop.primary && prop.kind === core_1.ReferenceKind.MANY_TO_ONE);
+            .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 = core_1.ReferenceKind.ONE_TO_ONE;
+            oneToOneCandidateProperties[0].kind = ReferenceKind.ONE_TO_ONE;
         }
         return meta;
     }
@@ -595,9 +592,9 @@ class DatabaseTable {
         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 : (core_1.Utils.keys(core_1.t).find(k => {
+        const type = fk ? runtimeType : (Utils.keys(t).find(k => {
             const typeInCoreMap = this.platform.getMappedType(k);
-            return (typeInCoreMap !== core_1.Type.getType(core_1.UnknownType) || k === 'unknown') && typeInCoreMap === column.mappedType;
+            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);
@@ -644,12 +641,12 @@ class DatabaseTable {
     }
     getReferenceKind(fk, unique) {
         if (fk && unique) {
-            return core_1.ReferenceKind.ONE_TO_ONE;
+            return ReferenceKind.ONE_TO_ONE;
         }
         if (fk) {
-            return core_1.ReferenceKind.MANY_TO_ONE;
+            return ReferenceKind.MANY_TO_ONE;
         }
-        return core_1.ReferenceKind.SCALAR;
+        return ReferenceKind.SCALAR;
     }
     getPropertyName(namingStrategy, baseName, fk) {
         let field = baseName;
@@ -701,7 +698,7 @@ class DatabaseTable {
         return '' + val;
     }
     addIndex(meta, index, type) {
-        const properties = core_1.Utils.unique(core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => {
+        const properties = Utils.unique(Utils.flatten(Utils.asArray(index.properties).map(prop => {
             const root = prop.replace(/\..+$/, '');
             if (meta.properties[prop]) {
                 if (meta.properties[prop].embeddedPath) {
@@ -713,7 +710,7 @@ class DatabaseTable {
             if (meta.properties[root]) {
                 return [prop.replace(root, meta.properties[root].fieldNames[0])];
             }
-            /* istanbul ignore next */
+            /* v8 ignore next */
             return [prop];
         })));
         if (properties.length === 0 && !index.expression) {
@@ -739,13 +736,12 @@ class DatabaseTable {
     }
     toJSON() {
         const { platform, columns, ...rest } = this;
-        const columnsMapped = core_1.Utils.keys(columns).reduce((o, col) => {
+        const columnsMapped = Utils.keys(columns).reduce((o, col) => {
             const { mappedType, ...restCol } = columns[col];
             o[col] = restCol;
-            o[col].mappedType = core_1.Utils.keys(core_1.t).find(k => core_1.t[k] === mappedType.constructor);
+            o[col].mappedType = Utils.keys(t).find(k => t[k] === mappedType.constructor);
             return o;
         }, {});
         return { columns: columnsMapped, ...rest };
     }
 }
-exports.DatabaseTable = DatabaseTable;

package/schema/SchemaComparator.d.ts

@@ -1,8 +1,8 @@
 import { type Dictionary } from '@mikro-orm/core';
-import type { Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings';
-import type { DatabaseSchema } from './DatabaseSchema';
-import type { DatabaseTable } from './DatabaseTable';
-import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
+import type { Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings.js';
+import type { DatabaseSchema } from './DatabaseSchema.js';
+import type { DatabaseTable } from './DatabaseTable.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
  */

package/schema/SchemaComparator.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaComparator = void 0;
-const node_util_1 = require("node:util");
-const core_1 = require("@mikro-orm/core");
+import { inspect } from 'node:util';
+import { ArrayType, BooleanType, DateTimeType, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
  */
-class SchemaComparator {
+export class SchemaComparator {
     platform;
     helper;
     logger;
@@ -311,7 +308,7 @@ class SchemaComparator {
             const [removedColumn, addedColumn] = candidateColumns[0];
             const removedColumnName = removedColumn.name;
             const addedColumnName = addedColumn.name;
-            /* istanbul ignore if */
+            /* v8 ignore next 3 */
             if (tableDifferences.renamedColumns[removedColumnName]) {
                 continue;
             }
@@ -399,8 +396,8 @@ class SchemaComparator {
         let toColumnType = this.platform.normalizeColumnType(toColumn.mappedType.getColumnType(toProp, this.platform).toLowerCase(), toProp);
         const log = (msg, params) => {
             if (logging) {
-                const copy = core_1.Utils.copy(params);
-                core_1.Utils.dropUndefinedProperties(copy);
+                const copy = Utils.copy(params);
+                Utils.dropUndefinedProperties(copy);
                 this.log(msg, copy);
             }
         };
@@ -441,8 +438,8 @@ class SchemaComparator {
             log(`'comment' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('comment');
         }
-        if (!(fromColumn.mappedType instanceof core_1.ArrayType) &&
-            !(toColumn.mappedType instanceof core_1.ArrayType) &&
+        if (!(fromColumn.mappedType instanceof ArrayType) &&
+            !(toColumn.mappedType instanceof ArrayType) &&
             this.diffEnumItems(fromColumn.enumItems, toColumn.enumItems)) {
             log(`'enumItems' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('enumItems');
@@ -521,30 +518,30 @@ class SchemaComparator {
         return simplify(expr1) !== simplify(expr2);
     }
     parseJsonDefault(defaultValue) {
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (!defaultValue) {
             return null;
         }
         const val = defaultValue
             .replace(/^(_\w+\\)?'(.*?)\\?'$/, '$2')
             .replace(/^\(?'(.*?)'\)?$/, '$1');
-        return (0, core_1.parseJsonSafe)(val);
+        return parseJsonSafe(val);
     }
     hasSameDefaultValue(from, to) {
         if (from.default == null || from.default.toString().toLowerCase() === 'null' || from.default.toString().startsWith('nextval(')) {
             return to.default == null || to.default.toLowerCase() === 'null';
         }
-        if (to.mappedType instanceof core_1.BooleanType) {
+        if (to.mappedType instanceof BooleanType) {
             const defaultValueFrom = !['0', 'false', 'f', 'n', 'no', 'off'].includes('' + from.default);
             const defaultValueTo = !['0', 'false', 'f', 'n', 'no', 'off'].includes('' + to.default);
             return defaultValueFrom === defaultValueTo;
         }
-        if (to.mappedType instanceof core_1.JsonType) {
+        if (to.mappedType instanceof JsonType) {
             const defaultValueFrom = this.parseJsonDefault(from.default);
             const defaultValueTo = this.parseJsonDefault(to.default);
-            return core_1.Utils.equals(defaultValueFrom, defaultValueTo);
+            return Utils.equals(defaultValueFrom, defaultValueTo);
         }
-        if (to.mappedType instanceof core_1.DateTimeType && from.default && to.default) {
+        if (to.mappedType instanceof DateTimeType && from.default && to.default) {
             // normalize now/current_timestamp defaults, also remove `()` from the end of default expression
             const defaultValueFrom = from.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');
             const defaultValueTo = to.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');
@@ -574,9 +571,8 @@ class SchemaComparator {
     }
     log(message, params) {
         if (params) {
-            message += ' ' + (0, node_util_1.inspect)(params);
+            message += ' ' + inspect(params);
         }
         this.logger.log('schema', message);
     }
 }
-exports.SchemaComparator = SchemaComparator;

package/schema/SchemaHelper.d.ts

@@ -1,9 +1,9 @@
 import { type Connection, type Dictionary } from '@mikro-orm/core';
-import type { AbstractSqlConnection } from '../AbstractSqlConnection';
-import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings';
-import type { DatabaseSchema } from './DatabaseSchema';
-import type { DatabaseTable } from './DatabaseTable';
+import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings.js';
+import type { DatabaseSchema } from './DatabaseSchema.js';
+import type { DatabaseTable } from './DatabaseTable.js';
 export declare abstract class SchemaHelper {
     protected readonly platform: AbstractSqlPlatform;
     constructor(platform: AbstractSqlPlatform);

package/schema/SchemaHelper.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaHelper = void 0;
-const core_1 = require("@mikro-orm/core");
-class SchemaHelper {
+import { RawQueryFragment, Utils } from '@mikro-orm/core';
+export class SchemaHelper {
     platform;
     constructor(platform) {
         this.platform = platform;
@@ -36,7 +33,7 @@ class SchemaHelper {
     }
     async getPrimaryKeys(connection, indexes = [], tableName, schemaName) {
         const pks = indexes.filter(i => i.primary).map(pk => pk.columnNames);
-        return core_1.Utils.flatten(pks);
+        return Utils.flatten(pks);
     }
     inferLengthFromColumnType(type) {
         const match = type.match(/^\w+\s*(?:\(\s*(\d+)\s*\)|$)/);
@@ -77,7 +74,7 @@ class SchemaHelper {
         return `alter table ${tableReference} rename column ${oldColumnName} to ${columnName}`;
     }
     getCreateIndexSQL(tableName, index) {
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (index.expression) {
             return index.expression;
         }
@@ -121,7 +118,7 @@ class SchemaHelper {
                     changedNativeEnums.push([column.nativeEnumName, column.enumItems, diff.fromTable.nativeEnums[key].items]);
                 }
             }
-            core_1.Utils.removeDuplicates(changedNativeEnums).forEach(([enumName, itemsNew, itemsOld]) => {
+            Utils.removeDuplicates(changedNativeEnums).forEach(([enumName, itemsNew, itemsOld]) => {
                 // postgres allows only adding new items, the values are case insensitive
                 itemsOld = itemsOld.map(v => v.toLowerCase());
                 const newItems = itemsNew.filter(val => !itemsOld.includes(val.toLowerCase()));
@@ -145,7 +142,7 @@ class SchemaHelper {
         for (const check of Object.values(diff.changedChecks)) {
             ret.push(this.dropConstraint(diff.name, check.name));
         }
-        /* istanbul ignore else */
+        /* v8 ignore next 3 */
         if (!safe && Object.values(diff.removedColumns).length > 0) {
             ret.push(this.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
         }
@@ -228,7 +225,7 @@ class SchemaHelper {
         const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
         return pkIndex?.keyName !== defaultName;
     }
-    /* istanbul ignore next */
+    /* v8 ignore next 3 */
     castColumn(name, type) {
         return '';
     }
@@ -259,17 +256,17 @@ class SchemaHelper {
         const columnType = column.type + (column.generated ? ` generated always as ${column.generated}` : '');
         const useDefault = column.default != null && column.default !== 'null' && !column.autoincrement;
         const col = [this.quote(column.name), columnType];
-        core_1.Utils.runIfNotEmpty(() => col.push('unsigned'), column.unsigned && this.platform.supportsUnsigned());
-        core_1.Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
-        core_1.Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
-        core_1.Utils.runIfNotEmpty(() => col.push('auto_increment'), column.autoincrement);
-        core_1.Utils.runIfNotEmpty(() => col.push('unique'), column.autoincrement && !column.primary);
+        Utils.runIfNotEmpty(() => col.push('unsigned'), column.unsigned && this.platform.supportsUnsigned());
+        Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
+        Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
+        Utils.runIfNotEmpty(() => col.push('auto_increment'), column.autoincrement);
+        Utils.runIfNotEmpty(() => col.push('unique'), column.autoincrement && !column.primary);
         if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
-            core_1.Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
+            Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
         }
-        core_1.Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
-        core_1.Utils.runIfNotEmpty(() => col.push(column.extra), column.extra);
-        core_1.Utils.runIfNotEmpty(() => col.push(`comment ${this.platform.quoteValue(column.comment)}`), column.comment);
+        Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
+        Utils.runIfNotEmpty(() => col.push(column.extra), column.extra);
+        Utils.runIfNotEmpty(() => col.push(`comment ${this.platform.quoteValue(column.comment)}`), column.comment);
         return col.join(' ');
     }
     getPreAlterTable(tableDiff, safe) {
@@ -322,7 +319,7 @@ class SchemaHelper {
         if (defaultValue == null) {
             return defaultValue;
         }
-        const raw = core_1.RawQueryFragment.getKnownFragment(defaultValue);
+        const raw = RawQueryFragment.getKnownFragment(defaultValue);
         if (raw) {
             return this.platform.formatQuery(raw.sql, raw.params);
         }
@@ -340,11 +337,11 @@ class SchemaHelper {
     getDropDatabaseSQL(name) {
         return `drop database if exists ${this.quote(name)}`;
     }
-    /* istanbul ignore next */
+    /* v8 ignore next 3 */
     getCreateNamespaceSQL(name) {
         return `create schema if not exists ${this.quote(name)}`;
     }
-    /* istanbul ignore next */
+    /* v8 ignore next 3 */
     getDropNamespaceSQL(name) {
         return `drop schema if exists ${this.quote(name)}`;
     }
@@ -369,13 +366,13 @@ class SchemaHelper {
             if (e instanceof Error && e.message.includes(this.getDatabaseNotExistsError(name))) {
                 return false;
             }
-            /* istanbul ignore next */
+            /* v8 ignore next */
             throw e;
         }
     }
     append(array, sql, pad = false) {
         const length = array.length;
-        for (const row of core_1.Utils.asArray(sql)) {
+        for (const row of Utils.asArray(sql)) {
             if (!row) {
                 continue;
             }
@@ -466,7 +463,7 @@ class SchemaHelper {
     getReferencedTableName(referencedTableName, schema) {
         const [schemaName, tableName] = this.splitTableName(referencedTableName);
         schema = schemaName ?? schema ?? this.platform.getConfig().get('schema');
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (schema && schemaName === '*') {
             return `${schema}.${referencedTableName.replace(/^\*\./, '')}`;
         }
@@ -542,4 +539,3 @@ class SchemaHelper {
         return sql;
     }
 }
-exports.SchemaHelper = SchemaHelper;

package/schema/SqlSchemaGenerator.d.ts

@@ -1,9 +1,9 @@
 import { AbstractSchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type DropSchemaOptions, type EnsureDatabaseOptions, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
-import type { SchemaDifference } from '../typings';
-import { DatabaseSchema } from './DatabaseSchema';
-import type { AbstractSqlDriver } from '../AbstractSqlDriver';
+import type { SchemaDifference } from '../typings.js';
+import { DatabaseSchema } from './DatabaseSchema.js';
+import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
 export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
-    protected readonly helper: import("./SchemaHelper").SchemaHelper;
+    protected readonly helper: import("./SchemaHelper.js").SchemaHelper;
     protected readonly options: {
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;