@mikro-orm/knex 5.7.15-dev.4 → 5.7.15-dev.41

package/AbstractSqlConnection.d.ts

@@ -12,11 +12,13 @@ export declare abstract class AbstractSqlConnection extends Connection {
     isConnected(): Promise<boolean>;
     transactional<T>(cb: (trx: Transaction<Knex.Transaction>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
         ctx?: Knex.Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
     }): Promise<T>;
     begin(options?: {
         isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
         ctx?: Knex.Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
     }): Promise<Knex.Transaction>;

package/AbstractSqlConnection.js

@@ -46,7 +46,10 @@ class AbstractSqlConnection extends core_1.Connection {
         if (!options.ctx) {
             await options.eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionStart);
         }
-        const trx = await (options.ctx || this.client).transaction(null, { isolationLevel: options.isolationLevel });
+        const trx = await (options.ctx || this.client).transaction(null, {
+            isolationLevel: options.isolationLevel,
+            readOnly: options.readOnly,
+        });
         if (!options.ctx) {
             await options.eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionStart, trx);
         }

package/AbstractSqlDriver.js

@@ -38,6 +38,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             .orderBy([...core_1.Utils.asArray(options.orderBy), ...joinedPropsOrderBy])
             .groupBy(options.groupBy)
             .having(options.having)
+            .indexHint(options.indexHint)
+            .comment(options.comments)
+            .hintComment(options.hintComments)
             .withSchema(this.getSchemaName(meta, options));
         if (options.limit !== undefined) {
             qb.limit(options.limit, options.offset);
@@ -105,7 +108,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     }
     async wrapVirtualExpressionInSubquery(meta, expression, where, options, type = query_1.QueryType.SELECT) {
         const qb = this.createQueryBuilder(meta.className, options?.ctx, options.connectionType, options.convertCustomTypes)
-            .limit(options?.limit, options?.offset);
+            .limit(options?.limit, options?.offset)
+            .indexHint(options.indexHint)
+            .comment(options.comments)
+            .hintComment(options.hintComments);
         if (options.orderBy) {
             qb.orderBy(options.orderBy);
         }
@@ -207,6 +213,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             return this.countVirtual(entityName, where, options);
         }
         const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false)
+            .indexHint(options.indexHint)
+            .comment(options.comments)
+            .hintComment(options.hintComments)
             .groupBy(options.groupBy)
             .having(options.having)
             .populate(options.populate ?? [])
@@ -335,7 +344,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 const uniqueFields = core_1.Utils.isPlainObject(where) ? Object.keys(where) : meta.primaryKeys;
                 /* istanbul ignore next */
                 qb.insert(data)
-                    .onConflict(uniqueFields.map(p => meta?.properties[p]?.fieldNames[0] ?? p))
+                    .onConflict(uniqueFields)
                     .merge(Object.keys(data).filter(f => !uniqueFields.includes(f)))
                     .returning(meta?.comparableProps.filter(p => !p.lazy && !p.embeddable && !(p.name in data)).map(p => p.name) ?? '*');
             }
@@ -357,7 +366,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const uniqueFields = core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]) : meta.primaryKeys;
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
             qb.insert(data)
-                .onConflict(uniqueFields.map(p => meta.properties[p]?.fieldNames[0] ?? p))
+                .onConflict(uniqueFields)
                 .merge(Object.keys(data[0]).filter(f => !uniqueFields.includes(f)))
                 .returning(meta.comparableProps.filter(p => !p.lazy && !p.embeddable && !(p.name in data[0])).map(p => p.name) ?? '*');
             return qb.execute('run', false);
@@ -461,11 +470,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (coll.property.reference === core_1.ReferenceType.ONE_TO_MANY) {
             const cols = coll.property.referencedColumnNames;
             const qb = this.createQueryBuilder(coll.property.type, ctx, 'write')
-                .withSchema(this.getSchemaName(meta, options))
-                .update({ [coll.property.mappedBy]: pks })
+                .withSchema(this.getSchemaName(meta, options));
+            if (coll.getSnapshot() === undefined) {
+                if (coll.property.orphanRemoval) {
+                    const kqb = qb.delete({ [coll.property.mappedBy]: pks })
+                        .getKnexQuery()
+                        .whereNotIn(cols, insertDiff);
+                    return this.rethrow(this.execute(kqb));
+                }
+                const kqb = qb.update({ [coll.property.mappedBy]: null })
+                    .getKnexQuery()
+                    .whereNotIn(cols, insertDiff);
+                return this.rethrow(this.execute(kqb));
+            }
+            const kqb = qb.update({ [coll.property.mappedBy]: pks })
                 .getKnexQuery()
                 .whereIn(cols, insertDiff);
-            return this.rethrow(this.execute(qb));
+            return this.rethrow(this.execute(kqb));
         }
         /* istanbul ignore next */
         const ownerSchema = wrapped.getSchema() === '*' ? this.config.get('schema') : wrapped.getSchema();
@@ -489,17 +510,22 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         else {
             where = { ...where, ...cond };
         }
+        /* istanbul ignore if */
+        options = { ...options };
         orderBy = this.getPivotOrderBy(prop, orderBy);
-        const qb = this.createQueryBuilder(prop.type, ctx, options?.connectionType)
+        const qb = this.createQueryBuilder(prop.type, ctx, options.connectionType)
+            .indexHint(options.indexHint)
+            .comment(options.comments)
+            .hintComment(options.hintComments)
             .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES)
             .withSchema(this.getSchemaName(prop.targetMeta, options));
         const populate = this.autoJoinOneToOneOwner(prop.targetMeta, [{ field: prop.pivotEntity }]);
-        const fields = this.buildFields(prop.targetMeta, (options?.populate ?? []), [], qb, options?.fields);
-        qb.select(fields).populate(populate).where(where).orderBy(orderBy).setLockMode(options?.lockMode, options?.lockTableAliases);
-        if (owners.length === 1 && (options?.offset != null || options?.limit != null)) {
+        const fields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, options.fields);
+        qb.select(fields).populate(populate).where(where).orderBy(orderBy).setLockMode(options.lockMode, options.lockTableAliases);
+        if (owners.length === 1 && (options.offset != null || options.limit != null)) {
             qb.limit(options.limit, options.offset);
         }
-        if (prop.targetMeta.schema !== '*' && pivotMeta.schema === '*' && options?.schema) {
+        if (prop.targetMeta.schema !== '*' && pivotMeta.schema === '*' && options.schema) {
             // eslint-disable-next-line dot-notation
             qb['finalize']();
             // eslint-disable-next-line dot-notation
@@ -672,9 +698,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (!deleteDiff) {
             deleteDiff = [];
         }
+        const pivotMeta = this.metadata.find(prop.pivotEntity);
         if (deleteDiff === true || deleteDiff.length > 0) {
             const qb1 = this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write')
-                .withSchema(this.getSchemaName(meta, options))
+                .withSchema(this.getSchemaName(pivotMeta, options))
                 .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
             const knex = qb1.getKnex();
             if (Array.isArray(deleteDiff)) {
@@ -700,7 +727,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             await core_1.Utils.runSerial(items, item => {
                 return this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write')
                     .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES)
-                    .withSchema(this.getSchemaName(meta, options))
+                    .withSchema(this.getSchemaName(pivotMeta, options))
                     .insert(item)
                     .execute('run', false);
             });
@@ -754,7 +781,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         if (prop.reference === core_1.ReferenceType.EMBEDDED) {
             if (prop.object) {
-                ret.push(prop.fieldNames[0]);
+                ret.push(prop.name);
                 return;
             }
             const parts = field.split('.');
@@ -766,13 +793,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }
             return;
         }
-        if (prop.formula) {
-            ret.push(prop.name);
-            return;
-        }
-        if (prop.fieldNames) {
-            ret.push(...prop.fieldNames);
-        }
+        ret.push(prop.name);
     }
     buildFields(meta, populate, joinedProps, qb, fields) {
         const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => p.field === prop.name || p.all));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "5.7.15-dev.4",
+  "version": "5.7.15-dev.41",
   "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,9 +66,9 @@
     "@mikro-orm/core": "^5.7.14"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~5.7.15-dev.4",
-    "@mikro-orm/entity-generator": "~5.7.15-dev.4",
-    "@mikro-orm/migrations": "~5.7.15-dev.4",
+    "@mikro-orm/core": "~5.7.15-dev.41",
+    "@mikro-orm/entity-generator": "~5.7.15-dev.41",
+    "@mikro-orm/migrations": "~5.7.15-dev.41",
     "better-sqlite3": "*",
     "mssql": "*",
     "mysql": "*",

package/query/QueryBuilder.d.ts

@@ -34,7 +34,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private readonly context?;
     private connectionType?;
     private readonly em?;
-    get mainAlias(): Alias;
+    get mainAlias(): Alias<T>;
     get alias(): string;
     get helper(): QueryBuilderHelper;
     /** @internal */
@@ -66,6 +66,8 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private _joinedProps;
     private _cache?;
     private _indexHint?;
+    private _comments;
+    private _hintComments;
     private flushMode?;
     private lockMode?;
     private lockTables?;
@@ -132,6 +134,16 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * Adds index hint to the FROM clause.
      */
     indexHint(sql: string): this;
+    /**
+     * Prepend comment to the sql query using the syntax `/* ... *&#8205;/`. Some characters are forbidden such as `/*, *&#8205;/` and `?`.
+     */
+    comment(comment: string | string[]): this;
+    /**
+     * Add hints to the query using comment-like syntax `/*+ ... *&#8205;/`. MySQL and Oracle use this syntax for optimizer hints.
+     * Also various DB proxies and routers use this syntax to pass hints to alter their behavior. In other dialects the hints
+     * are ignored as simple comments.
+     */
+    hintComment(comment: string | string[]): this;
     /**
      * Specifies FROM which entity's table select/update/delete will be executed, removing all previously set FROM-s.
      * Allows setting a main string alias of the selection data.

package/query/QueryBuilder.js

@@ -60,6 +60,8 @@ class QueryBuilder {
         this._groupBy = [];
         this._having = {};
         this._joinedProps = new Map();
+        this._comments = [];
+        this._hintComments = [];
         this.subQueries = {};
         this._aliases = {};
         this.platform = this.driver.getPlatform();
@@ -244,9 +246,16 @@ class QueryBuilder {
         return this;
     }
     onConflict(fields = []) {
+        const meta = this.mainAlias.metadata;
         this.ensureNotFinalized();
-        this._onConflict = this._onConflict || [];
-        this._onConflict.push({ fields: core_1.Utils.asArray(fields).map(f => f.toString()) });
+        this._onConflict ?? (this._onConflict = []);
+        this._onConflict.push({
+            fields: core_1.Utils.asArray(fields).flatMap(f => {
+                const key = f.toString();
+                /* istanbul ignore next */
+                return meta.properties[key]?.fieldNames ?? [key];
+            }),
+        });
         return this;
     }
     ignore() {
@@ -345,6 +354,24 @@ class QueryBuilder {
         this._indexHint = sql;
         return this;
     }
+    /**
+     * Prepend comment to the sql query using the syntax `/* ... *‍/`. Some characters are forbidden such as `/*, *‍/` and `?`.
+     */
+    comment(comment) {
+        this.ensureNotFinalized();
+        this._comments.push(...core_1.Utils.asArray(comment));
+        return this;
+    }
+    /**
+     * Add hints to the query using comment-like syntax `/*+ ... *‍/`. MySQL and Oracle use this syntax for optimizer hints.
+     * Also various DB proxies and routers use this syntax to pass hints to alter their behavior. In other dialects the hints
+     * are ignored as simple comments.
+     */
+    hintComment(comment) {
+        this.ensureNotFinalized();
+        this._hintComments.push(...core_1.Utils.asArray(comment));
+        return this;
+    }
     from(target, aliasName) {
         this.ensureNotFinalized();
         if (target instanceof QueryBuilder) {
@@ -374,6 +401,8 @@ class QueryBuilder {
         }, this._orderBy);
         core_1.Utils.runIfNotEmpty(() => qb.limit(this._limit), this._limit != null);
         core_1.Utils.runIfNotEmpty(() => qb.offset(this._offset), this._offset);
+        core_1.Utils.runIfNotEmpty(() => this._comments.forEach(comment => qb.comment(comment)), this._comments);
+        core_1.Utils.runIfNotEmpty(() => this._hintComments.forEach(comment => qb.hintComment(comment)), this._hintComments);
         core_1.Utils.runIfNotEmpty(() => this.helper.appendOnConflictClause(this.type ?? enums_1.QueryType.SELECT, this._onConflict, qb), this._onConflict);
         if (this.type === enums_1.QueryType.TRUNCATE && this.platform.usesCascadeStatement()) {
             return this.knex.raw(qb.toSQL().toNative().sql + ' cascade');
@@ -570,6 +599,7 @@ class QueryBuilder {
         const properties = [
             'flags', '_populate', '_populateWhere', '_populateMap', '_joins', '_joinedProps', '_cond', '_data', '_orderBy',
             '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
+            '_comments', '_hintComments',
         ];
         properties.forEach(prop => qb[prop] = core_1.Utils.copy(this[prop]));
         /* istanbul ignore else */
@@ -686,6 +716,10 @@ class QueryBuilder {
                 }
                 return;
             }
+            if (prop && prop.fieldNames.length > 1) {
+                ret.push(...prop.fieldNames.map(f => this.helper.mapper(f, this.type)));
+                return;
+            }
             ret.push(this.helper.mapper(field, this.type));
         });
         const meta = this.mainAlias.metadata;

package/query/QueryBuilderHelper.d.ts

@@ -16,7 +16,7 @@ export declare class QueryBuilderHelper {
     private readonly driver;
     private readonly platform;
     private readonly metadata;
-    constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias>, subQueries: Dictionary<string>, knex: Knex, driver: AbstractSqlDriver);
+    constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, knex: Knex, driver: AbstractSqlDriver);
     mapper(field: string | Knex.Raw, type?: QueryType): string;
     mapper(field: string | Knex.Raw, type?: QueryType, value?: any, alias?: string | null): string;
     processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
@@ -61,9 +61,9 @@ export declare class QueryBuilderHelper {
     isTableNameAliasRequired(type?: QueryType): boolean;
     private mapData;
 }
-export interface Alias {
+export interface Alias<T> {
     aliasName: string;
     entityName: string;
-    metadata?: EntityMetadata;
+    metadata?: EntityMetadata<T>;
     subQuery?: Knex.QueryBuilder;
 }

package/query/QueryBuilderHelper.js

@@ -128,12 +128,13 @@ class QueryBuilderHelper {
         const pivotMeta = this.metadata.find(prop.pivotEntity);
         const ret = {
             [`${ownerAlias}.${prop.name}#${pivotAlias}`]: {
-                prop, type, cond, ownerAlias,
+                prop, type, ownerAlias,
                 alias: pivotAlias,
                 inverseAlias: alias,
                 joinColumns: prop.joinColumns,
                 inverseJoinColumns: prop.inverseJoinColumns,
                 primaryKeys: prop.referencedColumnNames,
+                cond: {},
                 table: pivotMeta.tableName,
                 schema: this.driver.getSchemaName(pivotMeta),
                 path: path.endsWith('[pivot]') ? path : `${path}[pivot]`,
@@ -143,7 +144,7 @@ class QueryBuilderHelper {
             return ret;
         }
         const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
-        ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type);
+        ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type, cond);
         ret[`${pivotAlias}.${prop2.name}#${alias}`].path = path;
         return ret;
     }

package/schema/DatabaseTable.d.ts

@@ -17,6 +17,7 @@ export declare class DatabaseTable {
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getColumns(): Column[];
     getColumn(name: string): Column | undefined;
+    removeColumn(name: string): void;
     getIndexes(): Index[];
     getChecks(): Check[];
     init(cols: Column[], indexes: Index[] | undefined, checks: Check<unknown>[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;

package/schema/DatabaseTable.js

@@ -24,6 +24,9 @@ class DatabaseTable {
     getColumn(name) {
         return this.columns[name];
     }
+    removeColumn(name) {
+        delete this.columns[name];
+    }
     getIndexes() {
         return this.indexes;
     }
@@ -227,6 +230,8 @@ class DatabaseTable {
             primary: column.primary,
             fieldName: column.name,
             length: column.length,
+            precision: column.precision,
+            scale: column.scale,
             index: index ? index.keyName : undefined,
             unique: unique ? unique.keyName : undefined,
             enum: !!column.enumItems?.length,