@mikro-orm/knex 6.3.13-dev.1 → 6.3.13-dev.10

package/dialects/mysql/MySqlColumnCompiler.d.ts

@@ -1,7 +1,7 @@
 import BaseMySqlColumnCompiler from 'knex/lib/dialects/mysql/schema/mysql-columncompiler';
-import type { IncrementOptions } from '../../typings';
+import type { MySqlIncrementOptions } from '../../typings';
 export declare class MySqlColumnCompiler extends BaseMySqlColumnCompiler {
-    increments(options: IncrementOptions): string;
-    bigincrements(options: IncrementOptions): string;
+    increments(options: MySqlIncrementOptions): string;
+    bigincrements(options: MySqlIncrementOptions): string;
     private generateDDL;
 }

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -1,9 +1,10 @@
 import type { Knex } from 'knex';
-import type { CheckDef, Column, IndexDef, TableDifference, Table, ForeignKey } from '../../typings';
+import type { CheckDef, Column, IndexDef, TableDifference, Table, ForeignKey, MySqlTableBuilder } from '../../typings';
 import { type Dictionary, type Type } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection';
 import { SchemaHelper } from '../../schema/SchemaHelper';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema';
+import type { DatabaseTable } from '../../schema/DatabaseTable';
 export declare class MySqlSchemaHelper extends SchemaHelper {
     private readonly _cache;
     static readonly DEFAULT_VALUES: {
@@ -22,6 +23,7 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     getAllChecks(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<CheckDef[]>>;
     getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
+    createTableColumn(table: MySqlTableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder | undefined;
     configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -180,6 +180,24 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
             .map(col => `alter table \`${tableDiff.name}\` modify \`${col.name}\` ${this.getColumnDeclarationSQL({ ...col, autoincrement: false })}`)
             .join(';\n');
     }
+    createTableColumn(table, column, fromTable, changedProperties, alter) {
+        const compositePK = fromTable.getPrimaryKey()?.composite;
+        if (column.autoincrement && !column.generated && !compositePK && column.primary) {
+            const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
+            if (column.mappedType instanceof core_1.BigIntType) {
+                return table.bigIncrements(column.name, { primaryKey, unsigned: column.unsigned, type: column.type });
+            }
+            return table.increments(column.name, { primaryKey, unsigned: column.unsigned, type: column.type });
+        }
+        if (column.mappedType instanceof core_1.EnumType && column.enumItems?.every(item => core_1.Utils.isString(item))) {
+            return table.enum(column.name, column.enumItems);
+        }
+        let columnType = column.type;
+        if (column.generated) {
+            columnType += ` generated always as ${column.generated}`;
+        }
+        return table.specificType(column.name, columnType);
+    }
     configureColumnDefault(column, col, knex, changedProperties) {
         if (changedProperties || column.default !== undefined) {
             if (column.default == null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.3.13-dev.1",
+  "version": "6.3.13-dev.10",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.3.12"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.3.13-dev.1",
+    "@mikro-orm/core": "6.3.13-dev.10",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/QueryBuilder.d.ts

@@ -31,6 +31,7 @@ type EntityRelations<T> = EntityKey<T, true>;
 type AddAliasesFromContext<Context> = Context[keyof Context] extends infer Join ? Join extends any ? Join extends [string, infer Alias, infer Type, any] ? `${Alias & string}.${EntityRelations<Type & {}>}` : never : never : never;
 export type QBField<Entity, RootAlias extends string, Context> = (EntityRelations<Entity> | `${RootAlias}.${EntityRelations<Entity>}` | AddAliasesFromContext<Context>) & {} | AnyString;
 export type QBField2<Entity, RootAlias extends string, Context> = (EntityKey<Entity> | `${RootAlias}.${EntityKey<Entity>}` | AddAliasesFromContext<Context>) & {} | AnyString;
+type EntityKeyOrString<Entity extends object = AnyEntity> = AnyString | keyof Entity;
 /**
  * SQL query builder with fluent interface.
  *
@@ -125,12 +126,12 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     addSelect(fields: Field<Entity> | Field<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     distinct(): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     /** postgres only */
-    distinctOn(fields: string | string[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    distinctOn(fields: EntityKeyOrString<Entity> | EntityKeyOrString<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     insert(data: RequiredEntityData<Entity> | RequiredEntityData<Entity>[]): InsertQueryBuilder<Entity>;
     update(data: EntityData<Entity>): UpdateQueryBuilder<Entity>;
     delete(cond?: QBFilterQuery): DeleteQueryBuilder<Entity>;
     truncate(): TruncateQueryBuilder<Entity>;
-    count(field?: string | string[], distinct?: boolean): CountQueryBuilder<Entity>;
+    count(field?: EntityKeyOrString<Entity> | EntityKeyOrString<Entity>[], distinct?: boolean): CountQueryBuilder<Entity>;
     join<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | Knex.QueryBuilder | QueryBuilder<any>, alias: Alias, cond?: QBFilterQuery, type?: JoinType, path?: string, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>>;
     innerJoin<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | Knex.QueryBuilder | QueryBuilder<any>, alias: Alias, cond?: QBFilterQuery, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>>;
     innerJoinLateral(field: Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
@@ -154,7 +155,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     orWhere(cond: QBFilterQuery<Entity>): this;
     orWhere(cond: string, params?: any[]): this;
     orderBy(orderBy: QBQueryOrderMap<Entity> | QBQueryOrderMap<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
-    groupBy(fields: (string | keyof Entity) | readonly (string | keyof Entity)[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    groupBy(fields: EntityKeyOrString<Entity> | readonly EntityKeyOrString<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     having(cond?: QBFilterQuery | string, params?: any[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     onConflict(fields?: Field<Entity> | Field<Entity>[]): InsertQueryBuilder<Entity>;
     ignore(): this;
@@ -251,7 +252,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     /**
      * Executes count query (without offset and limit), returning total count of results
      */
-    getCount(field?: string | string[], distinct?: boolean): Promise<number>;
+    getCount(field?: EntityKeyOrString<Entity> | EntityKeyOrString<Entity>[], distinct?: boolean): Promise<number>;
     /**
      * Executes the query, returning both array of results and total count query (without offset and limit).
      */

package/query/QueryBuilderHelper.js

@@ -129,7 +129,7 @@ class QueryBuilderHelper {
         data = this.driver.mapDataToFieldNames(data, true, meta?.properties, convertCustomTypes);
         if (!core_1.Utils.hasObjectKeys(data) && meta && multi) {
             /* istanbul ignore next */
-            data[meta.primaryKeys[0]] = this.platform.usesDefaultKeyword() ? this.knex.raw('default') : undefined;
+            data[meta.getPrimaryProps()[0].fieldNames[0]] = this.platform.usesDefaultKeyword() ? this.knex.raw('default') : undefined;
         }
         return data;
     }

package/schema/SchemaComparator.js

@@ -390,7 +390,7 @@ class SchemaComparator {
         const toProp = this.mapColumnToProperty({ ...toColumn, autoincrement: false });
         const fromColumnType = this.platform.normalizeColumnType(fromColumn.mappedType.getColumnType(fromProp, this.platform).toLowerCase(), fromProp);
         const fromNativeEnum = fromTable.nativeEnums[fromColumnType] ?? Object.values(fromTable.nativeEnums).find(e => e.name === fromColumnType && e.schema !== '*');
-        const toColumnType = this.platform.normalizeColumnType(toColumn.mappedType.getColumnType(toProp, this.platform).toLowerCase(), toProp);
+        let toColumnType = this.platform.normalizeColumnType(toColumn.mappedType.getColumnType(toProp, this.platform).toLowerCase(), toProp);
         const log = (msg, params) => {
             if (tableName) {
                 const copy = core_1.Utils.copy(params);
@@ -402,8 +402,13 @@ class SchemaComparator {
             (!fromNativeEnum || `${fromNativeEnum.schema}.${fromNativeEnum.name}` !== toColumnType) &&
             !(fromColumn.ignoreSchemaChanges?.includes('type') || toColumn.ignoreSchemaChanges?.includes('type')) &&
             !fromColumn.generated && !toColumn.generated) {
-            log(`'type' changed for column ${tableName}.${fromColumn.name}`, { fromColumnType, toColumnType });
-            changedProperties.add('type');
+            if (!toColumnType.includes('.') && fromTable.schema && fromTable.schema !== this.platform.getDefaultSchemaName()) {
+                toColumnType = `${fromTable.schema}.${toColumnType}`;
+            }
+            if (fromColumnType !== toColumnType) {
+                log(`'type' changed for column ${tableName}.${fromColumn.name}`, { fromColumnType, toColumnType });
+                changedProperties.add('type');
+            }
         }
         if (fromColumn.nullable !== toColumn.nullable && !fromColumn.generated && !toColumn.generated) {
             log(`'nullable' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });

package/schema/SchemaHelper.d.ts

@@ -2,7 +2,7 @@ import { type Connection, type Dictionary } from '@mikro-orm/core';
 import type { Knex } from 'knex';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
-import type { CheckDef, Column, ExpandedTableBuilder, ForeignKey, IndexDef, Table, TableDifference } from '../typings';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings';
 import type { DatabaseSchema } from './DatabaseSchema';
 import type { DatabaseTable } from './DatabaseTable';
 export declare abstract class SchemaHelper {
@@ -30,7 +30,7 @@ export declare abstract class SchemaHelper {
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
     getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
-    createTableColumn(table: ExpandedTableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder | undefined;
+    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder | undefined;
     configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;

package/schema/SchemaHelper.js

@@ -126,12 +126,12 @@ class SchemaHelper {
     }
     createTableColumn(table, column, fromTable, changedProperties, alter) {
         const compositePK = fromTable.getPrimaryKey()?.composite;
-        if (column.autoincrement && !column.generated && !compositePK && column.primary) {
+        if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
             const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
             if (column.mappedType instanceof core_1.BigIntType) {
-                return table.bigIncrements(column.name, { primaryKey, unsigned: column.unsigned, type: column.type });
+                return table.bigIncrements(column.name, { primaryKey });
             }
-            return table.increments(column.name, { primaryKey, unsigned: column.unsigned, type: column.type });
+            return table.increments(column.name, { primaryKey });
         }
         if (column.mappedType instanceof core_1.EnumType && column.enumItems?.every(item => core_1.Utils.isString(item))) {
             return table.enum(column.name, column.enumItems);

package/schema/SqlSchemaGenerator.js

@@ -284,7 +284,9 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 if (!column.nativeEnumName) {
                     continue;
                 }
-                const key = schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' + column.nativeEnumName : column.nativeEnumName;
+                const key = schemaName && schemaName !== this.platform.getDefaultSchemaName() && !column.nativeEnumName.includes('.')
+                    ? schemaName + '.' + column.nativeEnumName
+                    : column.nativeEnumName;
                 if (changedProperties.has('enumItems') && key in diff.fromTable.nativeEnums) {
                     changedNativeEnums.push([column.nativeEnumName, column.enumItems, diff.fromTable.nativeEnums[key].items]);
                 }
@@ -293,6 +295,11 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 // 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()));
+                if (enumName.includes('.')) {
+                    const [enumSchemaName, rawEnumName] = enumName.split('.');
+                    ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(rawEnumName, enumSchemaName, val, itemsNew, itemsOld))));
+                    return;
+                }
                 ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(enumName, schemaName, val, itemsNew, itemsOld))));
             });
         }

package/typings.d.ts

@@ -185,13 +185,13 @@ export interface ICriteriaNode<T extends object> {
     getPath(addIndex?: boolean): string;
     getPivotPath(path: string): string;
 }
-export type IncrementOptions = {
+export type MySqlIncrementOptions = {
     primaryKey?: boolean;
     unsigned?: boolean;
     type?: Column['type'];
 };
-export interface ExpandedTableBuilder extends Knex.TableBuilder {
-    increments(columnName?: string, options?: IncrementOptions): Knex.ColumnBuilder;
-    bigIncrements(columnName?: string, options?: IncrementOptions): Knex.ColumnBuilder;
+export interface MySqlTableBuilder extends Knex.TableBuilder {
+    increments(columnName?: string, options?: MySqlIncrementOptions): Knex.ColumnBuilder;
+    bigIncrements(columnName?: string, options?: MySqlIncrementOptions): Knex.ColumnBuilder;
 }
 export {};