@mikro-orm/knex 6.5.6-dev.4 → 6.5.6-dev.6

package/dialects/mysql/MySqlPlatform.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.5.6-dev.4",
+  "version": "6.5.6-dev.6",
   "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.5.5"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.5.6-dev.4",
+    "@mikro-orm/core": "6.5.6-dev.6",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/schema/DatabaseSchema.js

@@ -72,6 +72,7 @@ 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) {
@@ -100,7 +101,7 @@ class DatabaseSchema {
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
             meta.props
-                .filter(prop => this.shouldHaveColumn(meta, prop))
+                .filter(prop => this.shouldHaveColumn(meta, prop, skipColumns))
                 .forEach(prop => table.addColumnFromProperty(prop, meta, config));
             meta.indexes.forEach(index => table.addIndex(meta, index, 'index'));
             meta.uniques.forEach(index => table.addIndex(meta, index, 'unique'));
@@ -129,10 +130,25 @@ 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 === core_1.ReferenceKind.EMBEDDED && prop.object) {
             return true;
         }

package/schema/SchemaHelper.d.ts

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

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 DropSchemaOptions, type EnsureDatabaseOptions, type EntityMetadata, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
@@ -8,6 +8,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
+        skipTables?: (string | RegExp)[];
+        skipColumns?: import("@mikro-orm/core").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>;
@@ -60,5 +63,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     private createForeignKeys;
     private dump;
     private get knex();
+    private matchName;
+    private isTableSkipped;
 }
 export { SqlSchemaGenerator as SchemaGenerator };

package/schema/SqlSchemaGenerator.js

@@ -50,6 +50,15 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
         return DatabaseSchema_1.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);
         let ret = '';
@@ -486,6 +495,19 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
     get knex() {
         return this.connection.getKnex();
     }
+    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));
+    }
 }
 exports.SqlSchemaGenerator = SqlSchemaGenerator;
 exports.SchemaGenerator = SqlSchemaGenerator;