@mikro-orm/knex 7.0.0-dev.27 → 7.0.0-dev.28

package/AbstractSqlDriver.d.ts

@@ -72,7 +72,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, explicit: boolean, parentAlias?: string): QueryOrderMap<T>[];
     protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, parentPath?: string): QueryOrderMap<T>[];
     protected normalizeFields<T extends object>(fields: Field<T>[], prefix?: string): string[];
-    protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<T>[], populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>): void;
+    protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<T>[]): void;
     protected isPopulated<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>, hint: PopulateOptions<T>, name?: string): boolean;
     protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>): Field<T>[];
 }

package/AbstractSqlDriver.js

@@ -390,7 +390,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
             sql += ' ' + data.map(() => `select null as ${this.platform.quoteIdentifier(pks[0])}`).join(' union all ');
         }
         const addParams = (prop, row) => {
-            let value = row[prop.name] ?? prop.default;
+            const rowValue = row[prop.name];
+            if (prop.nullable && rowValue === null) {
+                params.push(null);
+                return;
+            }
+            let value = rowValue ?? prop.default;
             if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
                 if (prop.array && value) {
                     value = this.platform.cloneEmbeddable(value);
@@ -999,6 +1004,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
      * @internal
      */
     mapPropToFieldNames(qb, prop, tableAlias) {
+        if (prop.kind === ReferenceKind.EMBEDDED && !prop.object) {
+            return Object.values(prop.embeddedProps).flatMap(childProp => {
+                return this.mapPropToFieldNames(qb, childProp, tableAlias);
+            });
+        }
         const aliased = this.platform.quoteIdentifier(`${tableAlias}__${prop.fieldNames[0]}`);
         if (prop.customTypes?.some(type => type?.convertToJSValueSQL)) {
             return prop.fieldNames.map((col, idx) => {
@@ -1220,7 +1230,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return ret;
     }
-    processField(meta, prop, field, ret, populate, joinedProps, qb) {
+    processField(meta, prop, field, ret) {
         if (!prop || (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner)) {
             return;
         }
@@ -1233,7 +1243,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             const top = parts.shift();
             for (const key of Object.keys(prop.embeddedProps)) {
                 if (!top || key === top) {
-                    this.processField(meta, prop.embeddedProps[key], parts.join('.'), ret, populate, joinedProps, qb);
+                    this.processField(meta, prop.embeddedProps[key], parts.join('.'), ret);
                 }
             }
             return;
@@ -1275,7 +1285,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     where: {},
                     aliasMap: qb.getAliasMap(),
                 });
-                this.processField(meta, prop, parts.join('.'), ret, populate, joinedProps, qb);
+                this.processField(meta, prop, parts.join('.'), ret);
             }
             if (!options.fields.includes('*') && !options.fields.includes(`${qb.alias}.*`)) {
                 ret.unshift(...meta.primaryKeys.filter(pk => !options.fields.includes(pk)));

package/dialects/mysql/MySqlPlatform.js

@@ -81,7 +81,8 @@ export class MySqlPlatform extends AbstractSqlPlatform {
         }
         const indexName = super.getIndexName(tableName, columns, type);
         if (indexName.length > 64) {
-            return `${indexName.substring(0, 56 - type.length)}_${Utils.hash(indexName, 5)}_${type}`;
+            const hashAlgorithm = this.config.get('hashAlgorithm');
+            return `${indexName.substring(0, 56 - type.length)}_${Utils.hash(indexName, 5, hashAlgorithm)}_${type}`;
         }
         return indexName;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "7.0.0-dev.27",
+  "version": "7.0.0-dev.28",
   "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.",
   "type": "module",
   "exports": {
@@ -54,9 +54,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.4"
+    "@mikro-orm/core": "^6.5.7"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.27"
+    "@mikro-orm/core": "7.0.0-dev.28"
   }
 }

package/query/NativeQueryBuilder.js

@@ -261,7 +261,7 @@ export class NativeQueryBuilder {
         }
         if (this.options.where?.sql.trim()) {
             this.parts.push(`where ${this.options.where.sql}`);
-            this.params.push(...this.options.where.params);
+            this.options.where.params.forEach(p => this.params.push(p));
         }
         if (this.options.groupBy) {
             const fields = this.options.groupBy.map(field => this.quote(field));

package/query/QueryBuilder.js

@@ -917,6 +917,8 @@ export class QueryBuilder {
             aliasMap: this.getAliasMap(),
             aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
         });
+        const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.className, cond);
+        cond = criteriaNode.process(this, { ignoreBranching: true, alias });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
         path ??= `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? entityName)}.${prop.name}`;
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {

package/query/QueryBuilderHelper.js

@@ -358,7 +358,7 @@ export class QueryBuilderHelper {
             return;
         }
         parts.push(operator === '$or' ? `(${res.sql})` : res.sql);
-        params.push(...res.params);
+        res.params.forEach(p => params.push(p));
     }
     appendQuerySubCondition(type, cond, key) {
         const parts = [];
@@ -502,7 +502,7 @@ export class QueryBuilderHelper {
                 params.push(item);
             }
             else {
-                params.push(...value);
+                value.forEach(v => params.push(v));
             }
             return `(${value.map(() => '?').join(', ')})`;
         }

package/schema/DatabaseSchema.js

@@ -69,6 +69,7 @@ export class DatabaseSchema {
     static fromMetadata(metadata, platform, config, schemaName) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
         const nativeEnums = {};
+        const skipColumns = config.get('schemaGenerator').skipColumns || {};
         for (const meta of metadata) {
             for (const prop of meta.props) {
                 if (prop.nativeEnumName) {
@@ -97,7 +98,7 @@ export class DatabaseSchema {
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
             for (const prop of meta.props) {
-                if (!this.shouldHaveColumn(meta, prop)) {
+                if (!this.shouldHaveColumn(meta, prop, skipColumns)) {
                     continue;
                 }
                 table.addColumnFromProperty(prop, meta, config);
@@ -129,10 +130,25 @@ export class DatabaseSchema {
         return ((takeTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? true) &&
             !(skipTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? false));
     }
-    static shouldHaveColumn(meta, prop) {
+    static shouldHaveColumn(meta, prop, skipColumns) {
         if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {
             return false;
         }
+        // Check if column should be skipped
+        if (skipColumns) {
+            const tableName = meta.tableName;
+            const tableSchema = meta.schema;
+            const fullTableName = tableSchema ? `${tableSchema}.${tableName}` : tableName;
+            // Check for skipColumns by table name or fully qualified table name
+            const columnsToSkip = skipColumns[tableName] || skipColumns[fullTableName];
+            if (columnsToSkip) {
+                for (const fieldName of prop.fieldNames) {
+                    if (columnsToSkip.some(pattern => this.matchName(fieldName, pattern))) {
+                        return false;
+                    }
+                }
+            }
+        }
         if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
             return true;
         }

package/schema/SchemaHelper.d.ts

@@ -63,6 +63,8 @@ export declare abstract class SchemaHelper {
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
+        skipTables?: (string | RegExp)[];
+        skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
     };
     protected processComment(comment: string): string;

package/schema/SqlSchemaGenerator.d.ts

@@ -1,4 +1,4 @@
-import { AbstractSchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type DropSchemaOptions, type EnsureDatabaseOptions, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type Dictionary, type DropSchemaOptions, type EnsureDatabaseOptions, type EntityMetadata, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings.js';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
@@ -8,6 +8,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
+        skipTables?: (string | RegExp)[];
+        skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
     };
     protected lastEnsuredDatabase?: string;
@@ -18,6 +20,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
      */
     ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
     getTargetSchema(schema?: string): DatabaseSchema;
+    protected getOrderedMetadata(schema?: string): EntityMetadata[];
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
     dropSchema(options?: DropSchemaOptions): Promise<void>;
     createNamespace(name: string): Promise<void>;
@@ -54,5 +57,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     dropTableIfExists(name: string, schema?: string): Promise<void>;
     private wrapSchema;
     private append;
+    private matchName;
+    private isTableSkipped;
 }
 export { SqlSchemaGenerator as SchemaGenerator };

package/schema/SqlSchemaGenerator.js

@@ -47,6 +47,15 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
         return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName);
     }
+    getOrderedMetadata(schema) {
+        const metadata = super.getOrderedMetadata(schema);
+        // Filter out skipped tables
+        return metadata.filter(meta => {
+            const tableName = meta.tableName;
+            const tableSchema = meta.schema ?? schema ?? this.config.get('schema');
+            return !this.isTableSkipped(tableName, tableSchema);
+        });
+    }
     async getCreateSchemaSQL(options = {}) {
         const toSchema = this.getTargetSchema(options.schema);
         const ret = [];
@@ -346,6 +355,19 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     append(array, sql, pad) {
         return this.helper.append(array, sql, pad);
     }
+    matchName(name, nameToMatch) {
+        return typeof nameToMatch === 'string'
+            ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
+            : nameToMatch.test(name);
+    }
+    isTableSkipped(tableName, schemaName) {
+        const skipTables = this.options.skipTables;
+        if (!skipTables || skipTables.length === 0) {
+            return false;
+        }
+        const fullTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
+        return skipTables.some(pattern => this.matchName(tableName, pattern) || this.matchName(fullTableName, pattern));
+    }
 }
 // for back compatibility
 export { SqlSchemaGenerator as SchemaGenerator };