@mikro-orm/sql 7.0.0-rc.3 → 7.0.1-dev.0

package/schema/SchemaComparator.js

@@ -3,13 +3,13 @@ import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe,
  * Compares two Schemas and return an instance of SchemaDifference.
  */
 export class SchemaComparator {
-    platform;
-    helper;
-    logger;
+    #helper;
+    #logger;
+    #platform;
     constructor(platform) {
-        this.platform = platform;
-        this.helper = this.platform.getSchemaHelper();
-        this.logger = this.platform.getConfig().getLogger();
+        this.#platform = platform;
+        this.#helper = this.#platform.getSchemaHelper();
+        this.#logger = this.#platform.getConfig().getLogger();
     }
     /**
      * Returns a SchemaDifference object containing the differences between the schemas fromSchema and toSchema.
@@ -35,13 +35,13 @@ export class SchemaComparator {
         };
         const foreignKeysToTable = {};
         for (const namespace of toSchema.getNamespaces()) {
-            if (fromSchema.hasNamespace(namespace) || namespace === this.platform.getDefaultSchemaName()) {
+            if (fromSchema.hasNamespace(namespace) || namespace === this.#platform.getDefaultSchemaName()) {
                 continue;
             }
             diff.newNamespaces.add(namespace);
         }
         for (const namespace of fromSchema.getNamespaces()) {
-            if (toSchema.hasNamespace(namespace) || namespace === this.platform.getDefaultSchemaName()) {
+            if (toSchema.hasNamespace(namespace) || namespace === this.#platform.getDefaultSchemaName()) {
                 continue;
             }
             diff.removedNamespaces.add(namespace);
@@ -418,7 +418,7 @@ export class SchemaComparator {
         if (key1.deferMode !== key2.deferMode) {
             return true;
         }
-        if (key1.localTableName === key1.referencedTableName && !this.platform.supportsMultipleCascadePaths()) {
+        if (key1.localTableName === key1.referencedTableName && !this.#platform.supportsMultipleCascadePaths()) {
             return false;
         }
         if (key1.columnNames.some(col => tableDifferences.changedColumns[col]?.changedProperties.has('type'))) {
@@ -429,7 +429,9 @@ export class SchemaComparator {
             return (key[method] ?? defaultRule[0]).toLowerCase().replace(defaultRule[1], defaultRule[0]).replace(/"/g, '');
         };
         const compare = (method) => rule(key1, method) === rule(key2, method);
-        return !compare('updateRule') || !compare('deleteRule');
+        // Skip updateRule comparison for platforms that don't support ON UPDATE (e.g., Oracle)
+        const updateRuleDiffers = this.#platform.supportsOnUpdate() && !compare('updateRule');
+        return updateRuleDiffers || !compare('deleteRule');
     }
     /**
      * Returns the difference between the columns
@@ -438,10 +440,10 @@ export class SchemaComparator {
         const changedProperties = new Set();
         const fromProp = this.mapColumnToProperty({ ...fromColumn, autoincrement: false });
         const toProp = this.mapColumnToProperty({ ...toColumn, autoincrement: false });
-        const fromColumnType = this.platform.normalizeColumnType(fromColumn.mappedType.getColumnType(fromProp, this.platform).toLowerCase(), fromProp);
+        const fromColumnType = this.#platform.normalizeColumnType(fromColumn.mappedType.getColumnType(fromProp, this.#platform).toLowerCase(), fromProp);
         const fromNativeEnum = fromTable.nativeEnums[fromColumnType] ??
             Object.values(fromTable.nativeEnums).find(e => e.name === fromColumnType && e.schema !== '*');
-        let toColumnType = this.platform.normalizeColumnType(toColumn.mappedType.getColumnType(toProp, this.platform).toLowerCase(), toProp);
+        let toColumnType = this.#platform.normalizeColumnType(toColumn.mappedType.getColumnType(toProp, this.#platform).toLowerCase(), toProp);
         const log = (msg, params) => {
             if (logging) {
                 const copy = Utils.copy(params);
@@ -456,7 +458,7 @@ export class SchemaComparator {
             !toColumn.generated) {
             if (!toColumnType.includes('.') &&
                 fromTable.schema &&
-                fromTable.schema !== this.platform.getDefaultSchemaName()) {
+                fromTable.schema !== this.#platform.getDefaultSchemaName()) {
                 toColumnType = `${fromTable.schema}.${toColumnType}`;
             }
             if (fromColumnType !== toColumnType) {
@@ -476,7 +478,7 @@ export class SchemaComparator {
             log(`'autoincrement' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('autoincrement');
         }
-        if (!!fromColumn.unsigned !== !!toColumn.unsigned && this.platform.supportsUnsigned()) {
+        if (!!fromColumn.unsigned !== !!toColumn.unsigned && this.#platform.supportsUnsigned()) {
             log(`'unsigned' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('unsigned');
         }
@@ -573,7 +575,7 @@ export class SchemaComparator {
             // index that has no constraints.
             return true;
         }
-        if (this.platform.supportsDeferredUniqueConstraints() && index1.deferMode !== index2.deferMode) {
+        if (this.#platform.supportsDeferredUniqueConstraints() && index1.deferMode !== index2.deferMode) {
             return false;
         }
         return index1.primary === index2.primary && index1.unique === index2.unique;
@@ -697,15 +699,15 @@ export class SchemaComparator {
         if (from.default && to.default) {
             return from.default.toString().toLowerCase() === to.default.toString().toLowerCase();
         }
-        if (['', this.helper.getDefaultEmptyString()].includes(to.default) && from.default != null) {
-            return ['', this.helper.getDefaultEmptyString()].includes(from.default.toString());
+        if (['', this.#helper.getDefaultEmptyString()].includes(to.default) && from.default != null) {
+            return ['', this.#helper.getDefaultEmptyString()].includes(from.default.toString());
         }
         // eslint-disable-next-line eqeqeq
         return from.default == to.default; // == intentionally
     }
     mapColumnToProperty(column) {
-        const length = column.type.match(/\w+\((\d+)\)/);
-        const match = column.type.match(/\w+\((\d+), ?(\d+)\)/);
+        const length = /\w+\((\d+)\)/.exec(column.type);
+        const match = /\w+\((\d+), ?(\d+)\)/.exec(column.type);
         return {
             fieldNames: [column.name],
             columnTypes: [column.type],
@@ -720,6 +722,6 @@ export class SchemaComparator {
         if (params) {
             message += ' ' + inspect(params);
         }
-        this.logger.log('schema', message);
+        this.#logger.log('schema', message);
     }
 }

package/schema/SchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Connection, type Dictionary, RawQueryFragment } from '@mikro-orm/core';
+import { type Connection, type Dictionary, type Options, RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings.js';
@@ -71,18 +71,7 @@ export declare abstract class SchemaHelper {
     createCheck(table: DatabaseTable, check: CheckDef): string;
     protected getTableName(table: string, schema?: string): string;
     getTablesGroupedBySchemas(tables: Table[]): Map<string | undefined, Table[]>;
-    get options(): {
-        disableForeignKeys?: boolean;
-        disableForeignKeysForClear?: boolean;
-        createForeignKeyConstraints?: boolean;
-        ignoreSchema?: string[];
-        skipTables?: (string | RegExp)[];
-        skipViews?: (string | RegExp)[];
-        skipColumns?: Dictionary<(string | RegExp)[]>;
-        managementDbName?: string;
-        defaultUpdateRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
-        defaultDeleteRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
-    };
+    get options(): NonNullable<Options['schemaGenerator']>;
     protected processComment(comment: string): string;
     protected quote(...keys: (string | undefined)[]): string;
     dropForeignKey(tableName: string, constraintName: string): string;

package/schema/SchemaHelper.js

@@ -36,7 +36,7 @@ export class SchemaHelper {
         return Utils.flatten(pks);
     }
     inferLengthFromColumnType(type) {
-        const match = type.match(/^\w+\s*(?:\(\s*(\d+)\s*\)|$)/);
+        const match = /^\w+\s*(?:\(\s*(\d+)\s*\)|$)/.exec(type);
         if (!match) {
             return;
         }
@@ -416,6 +416,7 @@ export class SchemaHelper {
         return norm[0].replace('(?)', length != null ? `(${length})` : '');
     }
     getCreateDatabaseSQL(name) {
+        name = this.quote(name);
         // two line breaks to force separate execution
         return `create database ${name};\n\nuse ${name}`;
     }

package/schema/SqlSchemaGenerator.d.ts

@@ -1,22 +1,12 @@
-import { 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 ClearDatabaseOptions, type CreateSchemaOptions, type DropSchemaOptions, type EnsureDatabaseOptions, type EntityMetadata, type ISchemaGenerator, type MikroORM, type Options, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
 import { AbstractSchemaGenerator } from '@mikro-orm/core/schema';
 import type { SchemaDifference } from '../typings.js';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
+import type { SchemaHelper } from './SchemaHelper.js';
 export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
-    protected readonly helper: import("./SchemaHelper.js").SchemaHelper;
-    protected readonly options: {
-        disableForeignKeys?: boolean;
-        disableForeignKeysForClear?: boolean;
-        createForeignKeyConstraints?: boolean;
-        ignoreSchema?: string[];
-        skipTables?: (string | RegExp)[];
-        skipViews?: (string | RegExp)[];
-        skipColumns?: Dictionary<(string | RegExp)[]>;
-        managementDbName?: string;
-        defaultUpdateRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
-        defaultDeleteRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
-    };
+    protected readonly helper: SchemaHelper;
+    protected readonly options: NonNullable<Options['schemaGenerator']>;
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
     create(options?: CreateSchemaOptions): Promise<void>;

package/schema/SqlSchemaGenerator.js

@@ -1,4 +1,4 @@
-import { CommitOrderCalculator, Utils, } from '@mikro-orm/core';
+import { CommitOrderCalculator, TableNotFoundException, Utils, } from '@mikro-orm/core';
 import { AbstractSchemaGenerator } from '@mikro-orm/core/schema';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import { SchemaComparator } from './SchemaComparator.js';
@@ -128,11 +128,19 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         }
         const schema = options?.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
         for (const meta of this.getOrderedMetadata(schema).reverse()) {
-            await this.driver
-                .createQueryBuilder(meta.class, this.em?.getTransactionContext(), 'write', false)
-                .withSchema(schema)
-                .truncate()
-                .execute();
+            try {
+                await this.driver
+                    .createQueryBuilder(meta.class, this.em?.getTransactionContext(), 'write', false)
+                    .withSchema(schema)
+                    .truncate()
+                    .execute();
+            }
+            catch (e) {
+                if (this.platform.getExceptionConverter().convertException(e) instanceof TableNotFoundException) {
+                    continue;
+                }
+                throw e;
+            }
         }
         if (this.options.disableForeignKeysForClear) {
             await this.execute(this.helper.enableForeignKeysSQL());
@@ -372,7 +380,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
      */
     async createDatabase(name, options) {
         name ??= this.config.get('dbName');
-        const sql = this.helper.getCreateDatabaseSQL('' + this.platform.quoteIdentifier(name));
+        const sql = this.helper.getCreateDatabaseSQL(name);
         if (sql) {
             await this.execute(sql);
         }

package/typings.d.ts

@@ -171,7 +171,10 @@ export interface IQueryBuilder<T> {
     readonly alias: string;
     readonly type: QueryType;
     /** @internal */
-    _fields?: InternalField<T>[];
+    state: {
+        fields?: InternalField<T>[];
+        [key: string]: any;
+    };
     /** @internal */
     helper: any;
     select(fields: string | RawQueryFragment | (string | RawQueryFragment)[], distinct?: boolean): this;