@mikro-orm/knex 6.3.8-dev.8 → 6.3.8

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -12,7 +12,7 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
         'current_timestamp(?)': string[];
         '0': string[];
     };
-    getSchemaBeginning(charset: string): string;
+    getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
     finalizeTable(table: Knex.CreateTableBuilder, charset: string, collate?: string): void;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -10,8 +10,11 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
         'current_timestamp(?)': ['current_timestamp(?)'],
         '0': ['0', 'false'],
     };
-    getSchemaBeginning(charset) {
-        return `set names ${charset};\n${this.disableForeignKeysSQL()}\n\n`;
+    getSchemaBeginning(charset, disableForeignKeys) {
+        if (disableForeignKeys) {
+            return `set names ${charset};\n${this.disableForeignKeysSQL()}\n\n`;
+        }
+        return `set names ${charset};\n\n`;
     }
     disableForeignKeysSQL() {
         return 'set foreign_key_checks = 0;';

package/package.json

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

package/schema/SchemaHelper.d.ts

@@ -8,10 +8,10 @@ import type { DatabaseTable } from './DatabaseTable';
 export declare abstract class SchemaHelper {
     protected readonly platform: AbstractSqlPlatform;
     constructor(platform: AbstractSqlPlatform);
-    getSchemaBeginning(charset: string): string;
+    getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
-    getSchemaEnd(): string;
+    getSchemaEnd(disableForeignKeys?: boolean): string;
     finalizeTable(table: Knex.TableBuilder, charset: string, collate?: string): void;
     supportsSchemaConstraints(): boolean;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;

package/schema/SchemaHelper.js

@@ -7,8 +7,11 @@ class SchemaHelper {
     constructor(platform) {
         this.platform = platform;
     }
-    getSchemaBeginning(charset) {
-        return `${this.disableForeignKeysSQL()}\n\n`;
+    getSchemaBeginning(charset, disableForeignKeys) {
+        if (disableForeignKeys) {
+            return `${this.disableForeignKeysSQL()}\n`;
+        }
+        return '';
     }
     disableForeignKeysSQL() {
         return '';
@@ -16,8 +19,11 @@ class SchemaHelper {
     enableForeignKeysSQL() {
         return '';
     }
-    getSchemaEnd() {
-        return `${this.enableForeignKeysSQL()}\n`;
+    getSchemaEnd(disableForeignKeys) {
+        if (disableForeignKeys) {
+            return `${this.enableForeignKeysSQL()}\n`;
+        }
+        return '';
     }
     finalizeTable(table, charset, collate) {
         //

package/schema/SqlSchemaGenerator.js

@@ -51,7 +51,6 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         return DatabaseSchema_1.DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName);
     }
     async getCreateSchemaSQL(options = {}) {
-        const wrap = options.wrap ?? this.options.disableForeignKeys;
         const toSchema = this.getTargetSchema(options.schema);
         let ret = '';
         for (const namespace of toSchema.getNamespaces()) {
@@ -79,7 +78,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         for (const tableDef of toSchema.getTables()) {
             ret += await this.dump(this.helper.createSchemaBuilder(tableDef.schema).alterTable(tableDef.name, table => this.createForeignKeys(table, tableDef, options.schema)));
         }
-        return this.wrapSchema(ret, { wrap });
+        return this.wrapSchema(ret, options);
     }
     async dropSchema(options = {}) {
         if (options.dropDb) {
@@ -114,7 +113,6 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
     }
     async getDropSchemaSQL(options = {}) {
         await this.ensureDatabase();
-        const wrap = options.wrap ?? this.options.disableForeignKeys;
         const metadata = this.getOrderedMetadata(options.schema).reverse();
         const schemas = this.getTargetSchema(options.schema).getNamespaces();
         const schema = await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas);
@@ -122,7 +120,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         // remove FKs explicitly if we can't use cascading statement and we don't disable FK checks (we need this for circular relations)
         for (const meta of metadata) {
             const table = schema.getTable(meta.tableName);
-            if (!this.platform.usesCascadeStatement() && table && (!wrap || options.dropForeignKeys)) {
+            if (!this.platform.usesCascadeStatement() && table && (!this.options.disableForeignKeys || options.dropForeignKeys)) {
                 for (const fk of Object.values(table.getForeignKeys())) {
                     const builder = this.helper.createSchemaBuilder(table.schema).alterTable(table.name, tbl => {
                         tbl.dropForeign(fk.columnNames, fk.constraintName);
@@ -143,7 +141,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         if (options.dropMigrationsTable) {
             ret += await this.dump(this.dropTable(this.config.get('migrations').tableName, this.config.get('schema')), '\n');
         }
-        return this.wrapSchema(ret + '\n', { wrap });
+        return this.wrapSchema(ret + '\n', options);
     }
     getSchemaName(meta, options) {
         const schemaName = options.schema ?? this.config.get('schema');
@@ -175,7 +173,6 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         };
     }
     async prepareSchemaForComparison(options) {
-        options.wrap ??= this.options.disableForeignKeys;
         options.safe ??= false;
         options.dropTables ??= true;
         const toSchema = this.getTargetSchema(options.schema);
@@ -439,13 +436,12 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         await core_1.Utils.runSerial(groups.flat(), line => this.driver.execute(line));
     }
     wrapSchema(sql, options) {
-        options.wrap ??= this.options.disableForeignKeys;
-        if (!options.wrap || sql.trim() === '') {
+        if (options.wrap === false || sql.trim() === '') {
             return sql;
         }
-        let ret = this.helper.getSchemaBeginning(this.config.get('charset'));
+        let ret = this.helper.getSchemaBeginning(this.config.get('charset'), this.options.disableForeignKeys);
         ret += sql;
-        ret += this.helper.getSchemaEnd();
+        ret += this.helper.getSchemaEnd(this.options.disableForeignKeys);
         return ret;
     }
     dropIndex(table, index, oldIndexName = index.keyName) {