@mikro-orm/knex 6.3.14-dev.4 → 6.3.14-dev.41

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.4",
+  "version": "6.3.14-dev.41",
   "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.13"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.3.14-dev.4",
+    "@mikro-orm/core": "6.3.14-dev.41",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/QueryBuilder.js

@@ -691,7 +691,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 +1050,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 +1068,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 +1337,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.js

@@ -583,7 +583,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) {

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;