@mikro-orm/knex 6.3.14-dev.9 → 6.4.0

package/AbstractSqlConnection.d.ts

@@ -22,8 +22,10 @@ export declare abstract class AbstractSqlConnection extends Connection {
      * @inheritDoc
      */
     checkConnection(): Promise<{
-        ok: boolean;
-        reason?: string;
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
         error?: Error;
     }>;
     transactional<T>(cb: (trx: Transaction<Knex.Transaction>) => Promise<T>, options?: {

package/AbstractSqlConnection.js

@@ -109,6 +109,7 @@ class AbstractSqlConnection extends core_1.Connection {
             queryOrKnex = q.sql;
             params = q.bindings;
         }
+        queryOrKnex = this.config.get('onQuery')(queryOrKnex, params);
         const formatted = this.platform.formatQuery(queryOrKnex, params);
         const sql = this.getSql(queryOrKnex, formatted, loggerContext);
         return this.executeQuery(sql, async () => {

package/AbstractSqlDriver.js

@@ -570,7 +570,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         for (const key of keys) {
             const prop = meta.properties[key] ?? meta.root.properties[key];
             prop.fieldNames.forEach((fieldName, fieldNameIdx) => {
-                if (fields.has(fieldName)) {
+                if (fields.has(fieldName) || (prop.ownColumns && !prop.ownColumns.includes(fieldName))) {
                     return;
                 }
                 fields.add(fieldName);

package/index.mjs

@@ -199,6 +199,7 @@ export const TimeType = mod.TimeType;
 export const TinyIntType = mod.TinyIntType;
 export const TransactionContext = mod.TransactionContext;
 export const TransactionEventBroadcaster = mod.TransactionEventBroadcaster;
+export const Transactional = mod.Transactional;
 export const Type = mod.Type;
 export const Uint8ArrayType = mod.Uint8ArrayType;
 export const UnderscoreNamingStrategy = mod.UnderscoreNamingStrategy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.3.14-dev.9",
+  "version": "6.4.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,10 +63,10 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.3.13"
+    "@mikro-orm/core": "^6.4.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.3.14-dev.9",
+    "@mikro-orm/core": "^6.0.0",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/QueryBuilder.d.ts

@@ -156,7 +156,9 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     orWhere(cond: string, params?: any[]): this;
     orderBy(orderBy: QBQueryOrderMap<Entity> | QBQueryOrderMap<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>;
+    having(cond?: QBFilterQuery | string, params?: any[], operator?: keyof typeof GroupOperator): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    andHaving(cond?: QBFilterQuery | string, params?: any[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    orHaving(cond?: QBFilterQuery | string, params?: any[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     onConflict(fields?: Field<Entity> | Field<Entity>[]): InsertQueryBuilder<Entity>;
     ignore(): this;
     merge(data?: EntityData<Entity> | Field<Entity>[]): this;

package/query/QueryBuilder.js

@@ -314,7 +314,7 @@ class QueryBuilder {
             this._cond = { [op]: cond1 };
         }
         if (this._onConflict) {
-            this._onConflict[this._onConflict.length - 1].where = this._cond;
+            this._onConflict[this._onConflict.length - 1].where = this.helper.processOnConflictCondition(this._cond, this._schema);
             this._cond = {};
         }
         return this;
@@ -348,14 +348,27 @@ class QueryBuilder {
         this._groupBy = core_1.Utils.asArray(fields);
         return this;
     }
-    having(cond = {}, params) {
+    having(cond = {}, params, operator) {
         this.ensureNotFinalized();
         if (core_1.Utils.isString(cond)) {
             cond = { [(0, core_1.raw)(`(${cond})`, params)]: [] };
         }
-        this._having = CriteriaNodeFactory_1.CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond).process(this);
+        cond = CriteriaNodeFactory_1.CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond).process(this);
+        if (!this._having || !operator) {
+            this._having = cond;
+        }
+        else {
+            const cond1 = [this._having, cond];
+            this._having = { [operator]: cond1 };
+        }
         return this;
     }
+    andHaving(cond, params) {
+        return this.having(cond, params, '$and');
+    }
+    orHaving(cond, params) {
+        return this.having(cond, params, '$or');
+    }
     onConflict(fields = []) {
         const meta = this.mainAlias.metadata;
         this.ensureNotFinalized();
@@ -691,7 +704,6 @@ class QueryBuilder {
                 const [propName] = hint.field.split(':', 2);
                 const value = core_1.Reference.unwrapReference(entity[propName]);
                 if (core_1.Utils.isEntity(value)) {
-                    (0, core_1.helper)(value).populated();
                     propagatePopulateHint(value, hint.children ?? []);
                 }
                 else if (core_1.Utils.isCollection(value)) {
@@ -1051,7 +1063,7 @@ class QueryBuilder {
             case enums_1.QueryType.SELECT:
                 qb.select(this.prepareFields(this._fields));
                 if (this._distinctOn) {
-                    qb.distinctOn(this._distinctOn);
+                    qb.distinctOn(this.prepareFields(this._distinctOn));
                 }
                 else if (this.flags.has(core_1.QueryFlag.DISTINCT)) {
                     qb.distinct();
@@ -1069,6 +1081,7 @@ class QueryBuilder {
                 break;
             case enums_1.QueryType.UPDATE:
                 qb.update(this._data);
+                this.helper.processJoins(qb, this._joins, joinSchema);
                 this.helper.updateVersionProperty(qb, this._data);
                 break;
             case enums_1.QueryType.DELETE:
@@ -1337,6 +1350,7 @@ class QueryBuilder {
         subSubQuery.__raw = true; // tag it as there is now way to check via `instanceof`
         const method = this.flags.has(core_1.QueryFlag.UPDATE_SUB_QUERY) ? 'update' : 'delete';
         this._cond = {}; // otherwise we would trigger validation error
+        this._joins = {}; // included in the subquery
         this[method](this._data).where({
             [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: subSubQuery },
         });

package/query/QueryBuilderHelper.d.ts

@@ -59,6 +59,7 @@ export declare class QueryBuilderHelper {
     private fieldName;
     getProperty(field: string, alias?: string): EntityProperty | undefined;
     isTableNameAliasRequired(type?: QueryType): boolean;
+    processOnConflictCondition(cond: QBFilterQuery, schema?: string): QBFilterQuery;
 }
 export interface Alias<T> {
     aliasName: string;

package/query/QueryBuilderHelper.js

@@ -471,13 +471,14 @@ class QueryBuilderHelper {
         if (fields.length > 1 && Array.isArray(value[op])) {
             const singleTuple = !value[op].every((v) => Array.isArray(v));
             if (!this.platform.allowsComparingTuples()) {
+                const mapped = fields.map(f => this.mapper(f, type));
                 if (op === '$in') {
                     const conds = value[op].map(() => {
-                        return `(${fields.map(field => `${this.platform.quoteIdentifier(field)} = ?`).join(' and ')})`;
+                        return `(${mapped.map(field => `${this.platform.quoteIdentifier(field)} = ?`).join(' and ')})`;
                     });
                     return void qb[m](this.knex.raw(`(${conds.join(' or ')})`, core_1.Utils.flatten(value[op])));
                 }
-                return void qb[m](this.knex.raw(`${fields.map(field => `${this.platform.quoteIdentifier(field)} = ?`).join(' and ')}`, core_1.Utils.flatten(value[op])));
+                return void qb[m](this.knex.raw(`${mapped.map(field => `${this.platform.quoteIdentifier(field)} = ?`).join(' and ')}`, core_1.Utils.flatten(value[op])));
             }
             if (singleTuple) {
                 const tmp = value[op].length === 1 && core_1.Utils.isPlainObject(value[op][0]) ? fields.map(f => value[op][0][f]) : value[op];
@@ -583,7 +584,7 @@ class QueryBuilderHelper {
             return;
         }
         if (type === enums_1.QueryType.UPDATE) {
-            const returningProps = meta.hydrateProps.filter(prop => core_1.Utils.isRawSql(data[prop.name]));
+            const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && core_1.Utils.isRawSql(data[prop.fieldNames[0]]));
             if (returningProps.length > 0) {
                 qb.returning(returningProps.flatMap(prop => {
                     if (prop.hasConvertToJSValueSQL) {
@@ -730,5 +731,15 @@ class QueryBuilderHelper {
     isTableNameAliasRequired(type) {
         return [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(type ?? enums_1.QueryType.SELECT);
     }
+    // workaround for https://github.com/knex/knex/issues/5257
+    processOnConflictCondition(cond, schema) {
+        const meta = this.metadata.get(this.entityName);
+        const tableName = this.driver.getTableName(meta, { schema }, false);
+        for (const key of Object.keys(cond)) {
+            const mapped = this.mapper(key, enums_1.QueryType.INSERT);
+            core_1.Utils.renameKey(cond, key, tableName + '.' + mapped);
+        }
+        return cond;
+    }
 }
 exports.QueryBuilderHelper = QueryBuilderHelper;

package/schema/DatabaseSchema.d.ts

@@ -34,9 +34,11 @@ export declare class DatabaseSchema {
     hasNamespace(namespace: string): boolean;
     hasNativeEnum(name: string): boolean;
     getNamespaces(): string[];
-    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[]): Promise<DatabaseSchema>;
+    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[]): Promise<DatabaseSchema>;
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): DatabaseSchema;
     private static getSchemaName;
+    private static matchName;
+    private static isTableNameAllowed;
     private static shouldHaveColumn;
     toJSON(): Dictionary;
     prune(schema: string | undefined, wildcardSchemaTables: string[]): void;

package/schema/DatabaseSchema.js

@@ -59,13 +59,13 @@ class DatabaseSchema {
     getNamespaces() {
         return [...this.namespaces];
     }
-    static async create(connection, platform, config, schemaName, schemas) {
+    static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
         const allTables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
         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 => t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName));
+        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);
         return schema;
     }
@@ -120,6 +120,15 @@ class DatabaseSchema {
     static getSchemaName(meta, config, schema) {
         return (meta.schema === '*' ? schema : meta.schema) ?? config.get('schema');
     }
+    static matchName(name, nameToMatch) {
+        return typeof nameToMatch === 'string'
+            ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
+            : nameToMatch.test(name);
+    }
+    static isTableNameAllowed(tableName, takeTables, skipTables) {
+        return ((takeTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? true) &&
+            !(skipTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? false));
+    }
     static shouldHaveColumn(meta, prop) {
         if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {
             return false;

package/schema/SchemaComparator.js

@@ -358,6 +358,9 @@ class SchemaComparator {
         if (key1.referencedColumnNames.join('~').toLowerCase() !== key2.referencedColumnNames.join('~').toLowerCase()) {
             return true;
         }
+        if (key1.constraintName !== key2.constraintName) {
+            return true;
+        }
         if (key1.referencedTableName !== key2.referencedTableName) {
             return true;
         }