@mikro-orm/knex 6.0.0-rc.0 → 6.0.0-rc.2

package/schema/SchemaComparator.js

@@ -22,7 +22,7 @@ class SchemaComparator {
      * operations to change the schema stored in fromSchema to the schema that is
      * stored in toSchema.
      */
-    compare(fromSchema, toSchema) {
+    compare(fromSchema, toSchema, inverseDiff) {
         const diff = { newTables: {}, removedTables: {}, changedTables: {}, orphanedForeignKeys: [], newNamespaces: new Set(), removedNamespaces: new Set(), fromSchema };
         const foreignKeysToTable = {};
         for (const namespace of toSchema.getNamespaces()) {
@@ -43,7 +43,7 @@ class SchemaComparator {
                 diff.newTables[tableName] = toSchema.getTable(tableName);
             }
             else {
-                const tableDifferences = this.diffTable(fromSchema.getTable(tableName), toSchema.getTable(tableName));
+                const tableDifferences = this.diffTable(fromSchema.getTable(tableName), toSchema.getTable(tableName), inverseDiff?.changedTables[tableName]);
                 if (tableDifferences !== false) {
                     diff.changedTables[tableName] = tableDifferences;
                 }
@@ -91,7 +91,7 @@ class SchemaComparator {
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.
      */
-    diffTable(fromTable, toTable) {
+    diffTable(fromTable, toTable, inverseTableDiff) {
         let changes = 0;
         const tableDifferences = {
             name: fromTable.getShortestName(),
@@ -157,7 +157,7 @@ class SchemaComparator {
             this.log(`column ${tableDifferences.name}.${column.name} changed`, { changedProperties });
             changes++;
         }
-        this.detectColumnRenamings(tableDifferences);
+        this.detectColumnRenamings(tableDifferences, inverseTableDiff);
         const fromTableIndexes = fromTable.getIndexes();
         const toTableIndexes = toTable.getIndexes();
         // See if all the indexes in "from" table exist in "to" table
@@ -249,7 +249,7 @@ class SchemaComparator {
      * Try to find columns that only changed their name, rename operations maybe cheaper than add/drop
      * however ambiguities between different possibilities should not lead to renaming at all.
      */
-    detectColumnRenamings(tableDifferences) {
+    detectColumnRenamings(tableDifferences, inverseTableDiff) {
         const renameCandidates = {};
         for (const addedColumn of Object.values(tableDifferences.addedColumns)) {
             for (const removedColumn of Object.values(tableDifferences.removedColumns)) {
@@ -257,6 +257,10 @@ class SchemaComparator {
                 if (diff.size !== 0) {
                     continue;
                 }
+                const renamedColumn = inverseTableDiff?.renamedColumns[addedColumn.name];
+                if (renamedColumn && renamedColumn?.name !== removedColumn.name) {
+                    continue;
+                }
                 renameCandidates[addedColumn.name] = renameCandidates[addedColumn.name] ?? [];
                 renameCandidates[addedColumn.name].push([removedColumn, addedColumn]);
             }
@@ -455,8 +459,8 @@ class SchemaComparator {
             return defaultValueFrom === defaultValueTo;
         }
         if (to.mappedType instanceof core_1.JsonType) {
-            const defaultValueFrom = (0, core_1.parseJsonSafe)(from.default.replace(/^'(.*)'$/, '$1'));
-            const defaultValueTo = (0, core_1.parseJsonSafe)(to.default?.replace(/^'(.*)'$/, '$1'));
+            const defaultValueFrom = (0, core_1.parseJsonSafe)(from.default.replace(/^(_\w+\\)?'(.*?)\\?'$/, '$2'));
+            const defaultValueTo = (0, core_1.parseJsonSafe)(to.default?.replace(/^\(?'(.*?)'\)?$/, '$1'));
             return core_1.Utils.equals(defaultValueFrom, defaultValueTo);
         }
         if (to.mappedType instanceof core_1.DateTimeType && from.default && to.default) {

package/schema/SchemaHelper.d.ts

@@ -23,7 +23,7 @@ export declare abstract class SchemaHelper {
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
-    getCreateIndexSQL(tableName: string, index: IndexDef): string;
+    getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
     getDropIndexSQL(tableName: string, index: IndexDef): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;

package/schema/SchemaHelper.js

@@ -77,14 +77,17 @@ class SchemaHelper {
         const tableReference = schemaReference + tableName;
         return `alter table ${tableReference} rename column ${oldColumnName} to ${columnName}`;
     }
-    getCreateIndexSQL(tableName, index) {
-        /* istanbul ignore if */
-        if (index.expression) {
+    getCreateIndexSQL(tableName, index, partialExpression = false) {
+        if (index.expression && !partialExpression) {
             return index.expression;
         }
         tableName = this.platform.quoteIdentifier(tableName);
         const keyName = this.platform.quoteIdentifier(index.keyName);
-        return `create index ${keyName} on ${tableName} (${index.columnNames.map(c => this.platform.quoteIdentifier(c)).join(', ')})`;
+        const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+        if (index.expression && partialExpression) {
+            return `${sql}(${index.expression})`;
+        }
+        return `${sql}(${index.columnNames.map(c => this.platform.quoteIdentifier(c)).join(', ')})`;
     }
     getDropIndexSQL(tableName, index) {
         return `drop index ${this.platform.quoteIdentifier(index.keyName)}`;

package/schema/SqlSchemaGenerator.js

@@ -143,7 +143,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
         const comparator = new SchemaComparator_1.SchemaComparator(this.platform);
         const diffUp = comparator.compare(fromSchema, toSchema);
-        const diffDown = comparator.compare(toSchema, fromSchema);
+        const diffDown = comparator.compare(toSchema, fromSchema, diffUp);
         return {
             up: await this.diffToSQL(diffUp, options),
             down: this.platform.supportsDownMigrations() ? await this.diffToSQL(diffDown, options) : '',
@@ -215,7 +215,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         if (schema && schemaName === '*') {
             return `${schema}.${referencedTableName.replace(/^\*\./, '')}`;
         }
-        if (schemaName === this.platform.getDefaultSchemaName()) {
+        if (!schemaName || schemaName === this.platform.getDefaultSchemaName()) {
             return tableName;
         }
         return `${schemaName}.${tableName}`;

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type } from '@mikro-orm/core';
+import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag } from '@mikro-orm/core';
 import type { JoinType, QueryType } from './query/enums';
 import type { DatabaseSchema, DatabaseTable } from './schema';
 export interface Table {
@@ -126,6 +126,7 @@ export interface IQueryBuilder<T> {
     truncate(): this;
     count(field?: string | string[], distinct?: boolean): this;
     join(field: string, alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string): this;
+    innerJoin(field: string, alias: string, cond?: QBFilterQuery): this;
     leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
     joinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
     leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
@@ -140,8 +141,19 @@ export interface IQueryBuilder<T> {
     orderBy(orderBy: QueryOrderMap<T>): this;
     groupBy(fields: (string | keyof T) | (string | keyof T)[]): this;
     having(cond?: QBFilterQuery | string, params?: any[]): this;
-    getAliasForJoinPath(path: string): string | undefined;
+    getAliasForJoinPath(path: string, options?: ICriteriaNodeProcessOptions): string | undefined;
+    getJoinForPath(path?: string, options?: ICriteriaNodeProcessOptions): JoinOptions | undefined;
     getNextAlias(entityName?: string): string;
+    clone(reset?: boolean): IQueryBuilder<T>;
+    setFlag(flag: QueryFlag): this;
+    unsetFlag(flag: QueryFlag): this;
+    hasFlag(flag: QueryFlag): boolean;
+}
+export interface ICriteriaNodeProcessOptions {
+    alias?: string;
+    matchPopulateJoins?: boolean;
+    ignoreBranching?: boolean;
+    preferNoBranch?: boolean;
 }
 export interface ICriteriaNode<T extends object> {
     readonly entityName: string;
@@ -150,7 +162,7 @@ export interface ICriteriaNode<T extends object> {
     payload: any;
     prop?: EntityProperty;
     index?: number;
-    process(qb: IQueryBuilder<T>, alias?: string): any;
+    process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string): boolean;
     shouldRename(payload: any): boolean;