@mikro-orm/knex 6.0.8-dev.9 → 6.1.1-dev.0

package/AbstractSqlDriver.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type Options, type OrderDefinition, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
+import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type ObjectQuery, type Options, type OrderDefinition, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from './AbstractSqlConnection';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 import { QueryBuilder, QueryType } from './query';
@@ -31,7 +31,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     private getPivotOrderBy;
-    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<T>;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     /**
      * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
      */
@@ -63,6 +63,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected extractManyToMany<T>(entityName: string, data: EntityDictionary<T>): EntityData<T>;
     protected processManyToMany<T extends object>(meta: EntityMetadata<T> | undefined, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
+    protected buildPopulateWhere<T extends object>(meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'populateWhere'>): ObjectQuery<T>;
     protected buildOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];
     protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, explicit: boolean, parentAlias?: string): QueryOrderMap<T>[];
     protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, parentPath?: string): QueryOrderMap<T>[];

package/AbstractSqlDriver.js

@@ -34,6 +34,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false, options.logging);
         const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options);
         const orderBy = this.buildOrderBy(qb, meta, populate, options);
+        const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
         core_1.Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));
         if (core_1.Utils.isPrimaryKey(where, meta.compositePK)) {
             where = { [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
@@ -43,7 +44,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         qb.__populateWhere = options._populateWhere;
         qb.select(fields)
             // only add populateWhere if we are populate-joining, as this will be used to add `on` conditions
-            .populate(populate, joinedProps.length > 0 ? options.populateWhere : undefined)
+            .populate(populate, joinedProps.length > 0 ? populateWhere : undefined)
             .where(where)
             .groupBy(options.groupBy)
             .having(options.having)
@@ -761,8 +762,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         return [];
     }
-    async execute(queryOrKnex, params = [], method = 'all', ctx) {
-        return this.rethrow(this.connection.execute(queryOrKnex, params, method, ctx));
+    async execute(queryOrKnex, params = [], method = 'all', ctx, loggerContext) {
+        return this.rethrow(this.connection.execute(queryOrKnex, params, method, ctx, loggerContext));
     }
     /**
      * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
@@ -981,6 +982,31 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         qb.select((0, core_1.raw)('1')).where(cond).setLockMode(options.lockMode, options.lockTableAliases);
         await this.rethrow(qb.execute());
     }
+    buildPopulateWhere(meta, joinedProps, options) {
+        const where = {};
+        for (const hint of joinedProps) {
+            const [propName] = hint.field.split(':', 2);
+            const prop = meta.properties[propName];
+            if (!core_1.Utils.isEmpty(prop.where)) {
+                where[prop.name] = core_1.Utils.copy(prop.where);
+            }
+            if (hint.children) {
+                const inner = this.buildPopulateWhere(prop.targetMeta, hint.children, {});
+                if (!core_1.Utils.isEmpty(inner)) {
+                    where[prop.name] ??= {};
+                    Object.assign(where[prop.name], inner);
+                }
+            }
+        }
+        if (core_1.Utils.isEmpty(options.populateWhere)) {
+            return where;
+        }
+        if (core_1.Utils.isEmpty(where)) {
+            return options.populateWhere;
+        }
+        /* istanbul ignore next */
+        return { $and: [options.populateWhere, where] };
+    }
     buildOrderBy(qb, meta, populate, options) {
         const joinedProps = this.joinedProps(meta, populate, options);
         // `options._populateWhere` is a copy of the value provided by user with a fallback to the global config option

package/SqlEntityManager.d.ts

@@ -19,7 +19,7 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
      * Returns configured knex instance.
      */
     getKnex(type?: ConnectionType): Knex<any, any[]>;
-    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run'): Promise<T>;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
     getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: string, where: FilterQuery<Entity>): FilterQuery<Entity>;
 }

package/SqlEntityManager.js

@@ -26,8 +26,8 @@ class SqlEntityManager extends core_1.EntityManager {
     getKnex(type) {
         return this.getConnection(type).getKnex();
     }
-    async execute(queryOrKnex, params = [], method = 'all') {
-        return this.getDriver().execute(queryOrKnex, params, method, this.getContext(false).getTransactionContext());
+    async execute(queryOrKnex, params = [], method = 'all', loggerContext) {
+        return this.getDriver().execute(queryOrKnex, params, method, this.getContext(false).getTransactionContext(), loggerContext);
     }
     getRepository(entityName) {
         return super.getRepository(entityName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.8-dev.9",
+  "version": "6.1.1-dev.0",
   "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",
@@ -63,9 +63,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.0.7"
+    "@mikro-orm/core": "^6.1.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.8-dev.9"
+    "@mikro-orm/core": "6.1.1-dev.0"
   }
 }

package/query/QueryBuilderHelper.js

@@ -205,7 +205,11 @@ class QueryBuilderHelper {
             for (const key of Object.keys(join.cond)) {
                 const hasPrefix = key.includes('.') || core_1.Utils.isOperator(key) || core_1.RawQueryFragment.isKnownFragment(key);
                 const newKey = hasPrefix ? key : `${join.alias}.${key}`;
-                conditions.push(this.processJoinClause(newKey, join.cond[key], join.alias, params));
+                const clause = this.processJoinClause(newKey, join.cond[key], join.alias, params);
+                /* istanbul ignore else */
+                if (clause !== '()') {
+                    conditions.push(clause);
+                }
             }
             let sql = method + ' ';
             if (join.subquery) {

package/schema/SchemaHelper.d.ts

@@ -27,10 +27,11 @@ export declare abstract class SchemaHelper {
     getDropIndexSQL(tableName: string, index: IndexDef): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
-    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>): Knex.ColumnBuilder;
+    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder;
     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;
+    getPostAlterTable(tableDiff: TableDifference, safe: boolean): string;
     getAlterColumnAutoincrement(tableName: string, column: Column, schemaName?: string): string;
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;

package/schema/SchemaHelper.js

@@ -104,7 +104,7 @@ class SchemaHelper {
         const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
         return pkIndex?.keyName !== defaultName;
     }
-    createTableColumn(table, column, fromTable, changedProperties) {
+    createTableColumn(table, column, fromTable, changedProperties, alter) {
         const compositePK = fromTable.getPrimaryKey()?.composite;
         if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
             const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
@@ -144,6 +144,9 @@ class SchemaHelper {
     getPreAlterTable(tableDiff, safe) {
         return '';
     }
+    getPostAlterTable(tableDiff, safe) {
+        return '';
+    }
     getAlterColumnAutoincrement(tableName, column, schemaName) {
         return '';
     }

package/schema/SqlSchemaGenerator.d.ts

@@ -37,6 +37,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
      * We need to drop foreign keys first for all tables to allow dropping PK constraints.
      */
     private preAlterTable;
+    private postAlterTable;
     private splitTableName;
     private alterTable;
     /**

package/schema/SqlSchemaGenerator.js

@@ -188,7 +188,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             }
         }
         for (const newTable of Object.values(schemaDiff.newTables)) {
-            ret += await this.dump(this.createTable(newTable));
+            ret += await this.dump(this.createTable(newTable, true));
         }
         for (const newTable of Object.values(schemaDiff.newTables)) {
             ret += await this.dump(this.createSchemaBuilder(newTable.schema).alterTable(newTable.name, table => {
@@ -210,6 +210,11 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 ret += await this.dump(builder);
             }
         }
+        for (const changedTable of Object.values(schemaDiff.changedTables)) {
+            for (const builder of this.postAlterTable(changedTable, options.safe)) {
+                ret += await this.dump(builder);
+            }
+        }
         if (options.dropTables && !options.safe) {
             for (const removedNamespace of schemaDiff.removedNamespaces) {
                 ret += await this.dump(this.knex.schema.dropSchema(removedNamespace));
@@ -263,6 +268,12 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         }));
         return ret;
     }
+    postAlterTable(diff, safe) {
+        const ret = [];
+        const push = (sql) => sql ? ret.push(this.knex.schema.raw(sql)) : undefined;
+        push(this.helper.getPostAlterTable(diff, safe));
+        return ret;
+    }
     splitTableName(name) {
         const parts = name.split('.');
         const tableName = parts.pop();
@@ -272,11 +283,19 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
     alterTable(diff, safe) {
         const ret = [];
         const [schemaName, tableName] = this.splitTableName(diff.name);
-        const changedNativeEnums = [];
-        for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
-            if (column.nativeEnumName && changedProperties.has('enumItems') && column.nativeEnumName in diff.fromTable.nativeEnums) {
-                changedNativeEnums.push([column.nativeEnumName, column.enumItems, diff.fromTable.getColumn(column.name).enumItems]);
+        if (this.platform.supportsNativeEnums()) {
+            const changedNativeEnums = [];
+            for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
+                if (column.nativeEnumName && changedProperties.has('enumItems') && column.nativeEnumName in diff.fromTable.nativeEnums) {
+                    changedNativeEnums.push([column.nativeEnumName, column.enumItems, diff.fromTable.getColumn(column.name).enumItems]);
+                }
             }
+            core_1.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()));
+                ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(enumName, schemaName, val))));
+            });
         }
         ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
             for (const index of Object.values(diff.removedIndexes)) {
@@ -300,7 +319,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         }));
         ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
             for (const column of Object.values(diff.addedColumns)) {
-                const col = this.helper.createTableColumn(table, column, diff.fromTable);
+                const col = this.helper.createTableColumn(table, column, diff.fromTable, undefined, true);
                 this.helper.configureColumn(column, col, this.knex);
                 const foreignKey = Object.values(diff.addedForeignKeys).find(fk => fk.columnNames.length === 1 && fk.columnNames[0] === column.name);
                 if (foreignKey && this.options.createForeignKeyConstraints) {
@@ -319,7 +338,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 if (changedProperties.size === 1 && changedProperties.has('enumItems') && column.nativeEnumName) {
                     continue;
                 }
-                const col = this.helper.createTableColumn(table, column, diff.fromTable, changedProperties).alter();
+                const col = this.helper.createTableColumn(table, column, diff.fromTable, changedProperties, true).alter();
                 this.helper.configureColumn(column, col, this.knex, changedProperties);
             }
             for (const { column } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('autoincrement'))) {
@@ -366,13 +385,6 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 table.comment(comment);
             }
         }));
-        if (this.platform.supportsNativeEnums()) {
-            changedNativeEnums.forEach(([enumName, itemsNew, itemsOld]) => {
-                // postgres allows only adding new items
-                const newItems = itemsNew.filter(val => !itemsOld.includes(val));
-                ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(enumName, schemaName, val))));
-            });
-        }
         return ret;
     }
     /**
@@ -422,10 +434,10 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         }
         return builder;
     }
-    createTable(tableDef) {
+    createTable(tableDef, alter) {
         return this.createSchemaBuilder(tableDef.schema).createTable(tableDef.name, table => {
             tableDef.getColumns().forEach(column => {
-                const col = this.helper.createTableColumn(table, column, tableDef);
+                const col = this.helper.createTableColumn(table, column, tableDef, undefined, alter);
                 this.helper.configureColumn(column, col, this.knex);
             });
             for (const index of tableDef.getIndexes()) {