@mikro-orm/sql 7.2.6-dev.8 → 7.2.6

package/AbstractSqlConnection.js

@@ -130,6 +130,10 @@ export class AbstractSqlConnection extends Connection {
             }
             catch (rollbackError) {
                 this.logger.warn('query', `Failed to roll back transaction: ${rollbackError.message}`);
+                // the inner writes are still part of the outer transaction, so it must not commit them
+                if (options.ctx) {
+                    options.ctx.failedSavepointRollback ??= new Error(`Cannot commit the transaction, rolling back to savepoint "${trx.savepointName}" failed: ${rollbackError.message}`, { cause: rollbackError });
+                }
             }
             throw error;
         }
@@ -203,6 +207,9 @@ export class AbstractSqlConnection extends Connection {
         if (ctx.isRolledBack) {
             return;
         }
+        if ('failedSavepointRollback' in ctx) {
+            throw ctx.failedSavepointRollback;
+        }
         await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionCommit, ctx);
         if ('savepointName' in ctx) {
             await ctx.releaseSavepoint(ctx.savepointName).execute();

package/AbstractSqlDriver.js

@@ -467,9 +467,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 return;
             }
             const mapToPk = !hint.dataOnly && !!(ref || prop.mapToPk);
-            const targetProps = mapToPk
-                ? meta2.getPrimaryProps()
-                : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
+            // all rows of a result share their columns, so resolve the mapped props once per join path
+            const joinedTargets = (map.joinedTargets ??= {});
+            const { targetProps, virtualProps } = (joinedTargets[path] ??= {
+                targetProps: (mapToPk
+                    ? meta2.getPrimaryProps()
+                    : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []))).filter(prop => prop.fieldNames.some(name => typeof root[`${relationAlias}__${name}`] !== 'undefined')),
+                virtualProps: meta2.props.filter(prop => !ref && prop.persist === false && prop.fieldNames),
+            });
             // If the primary key value for the relation is null, we know we haven't joined to anything
             // and therefore we don't return any record (since all values would be null)
             const hasPK = meta2.getPrimaryProps().every(pk => pk.fieldNames.every(name => {
@@ -490,9 +495,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 return;
             }
             let relationPojo = {};
-            meta2.props
-                .filter(prop => !ref && prop.persist === false && prop.fieldNames)
-                .forEach(prop => {
+            virtualProps.forEach(prop => {
                 /* v8 ignore next */
                 if (prop.fieldNames.length > 1) {
                     // composite keys
@@ -2115,7 +2118,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (prop.formula) {
             const quotedAlias = this.platform.quoteIdentifier(tableAlias).toString();
             const table = this.createFormulaTable(quotedAlias, meta, schema);
-            const columns = meta.createColumnMappingObject(p => qb.helper.getTPTAliasForProperty(p.name, tableAlias), tableAlias);
+            const columns = meta.createColumnMappingObject(p => qb.helper.getTPTAliasForProperty(p.name, tableAlias), quotedAlias);
             return [raw(`${this.evaluateFormula(prop.formula, columns, table)} as ${aliased}`)];
         }
         if (prop.customTypes?.some(type => !!type?.convertToJSValueSQL)) {
@@ -2539,9 +2542,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
             ret.push('*');
         }
         if (ret.length > 0 && !hasExplicitFields && addFormulas) {
-            // Create formula column mapping with unquoted aliases - quoting should be handled by the user via `quote` helper
+            // `toString()` must yield the quoted alias like `QueryBuilder.finalize()`, which dedupes formulas by rendered SQL
             const quotedAlias = this.platform.quoteIdentifier(alias);
-            const columns = meta.createColumnMappingObject(alias);
+            const columns = meta.createColumnMappingObject(alias, quotedAlias.toString());
             const effectiveSchema = schema ?? (meta.schema !== '*' ? meta.schema : undefined);
             for (const prop of meta.props) {
                 if (lazyProps.includes(prop)) {

package/AbstractSqlPlatform.js

@@ -96,7 +96,7 @@ export class AbstractSqlPlatform extends Platform {
             return this.formatQuery(value.sql, value.params);
         }
         if (Utils.isPlainObject(value) || value?.[JsonProperty]) {
-            return this.escape(JSON.stringify(value));
+            return this.escape(this.convertJsonToDatabaseValue(value));
         }
         return this.escape(value);
     }

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -16,6 +16,8 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     };
     /** mysql and mariadb treat null as the lowest value when no placement is requested. */
     sortsNullsLowest(): boolean;
+    /** mysql reads backslashes in string literals as escapes, so defaults need the same escaping as values (minus the needless `\"`). */
+    quoteDefaultValue(value: string): string;
     supportsMultiColumnCountDistinct(): boolean;
     /** @internal */
     createNativeQueryBuilder(): MySqlNativeQueryBuilder;

package/dialects/mysql/BaseMySqlPlatform.js

@@ -22,6 +22,10 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
     sortsNullsLowest() {
         return true;
     }
+    /** mysql reads backslashes in string literals as escapes, so defaults need the same escaping as values (minus the needless `\"`). */
+    quoteDefaultValue(value) {
+        return this.quoteValue(value).replaceAll('\\"', '"');
+    }
     supportsMultiColumnCountDistinct() {
         return true;
     }

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -62,4 +62,6 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     protected getChecksSQL(tables: Table[]): string;
     normalizeDefaultValue(defaultValue: string, length: number): string | number;
     protected wrap(val: string | null | undefined, type: Type<unknown>): string | null | undefined;
+    /** Decodes the backslash escapes of an introspected string literal. */
+    unescapeDefault(val: string): string;
 }

package/dialects/mysql/MySqlSchemaHelper.js

@@ -1,4 +1,4 @@
-import { EnumType, StringType, TextType } from '@mikro-orm/core';
+import { EnumType, JsonType, StringType, TextType, } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 export class MySqlSchemaHelper extends SchemaHelper {
     #cache = {};
@@ -601,7 +601,20 @@ export class MySqlSchemaHelper extends SchemaHelper {
         return super.normalizeDefaultValue(defaultValue, length, MySqlSchemaHelper.DEFAULT_VALUES);
     }
     wrap(val, type) {
+        if (typeof val !== 'string' || val.length === 0) {
+            return val;
+        }
+        // text/blob literal defaults come back escaped twice with a charset introducer, e.g. `_utf8mb4\'it\\\'s\'` (JSON is parsed by the comparator)
+        const expression = type instanceof JsonType ? null : /^_\w+\\'(.*)\\'$/s.exec(val);
+        if (expression) {
+            return this.platform.quoteDefaultValue(this.unescapeDefault(expression[1].replace(/\\(.)/gs, '$1')));
+        }
         const stringType = type instanceof StringType || type instanceof TextType || type instanceof EnumType;
-        return typeof val === 'string' && val.length > 0 && stringType ? this.platform.quoteValue(val) : val;
+        return stringType ? this.platform.quoteDefaultValue(val) : val;
+    }
+    /** Decodes the backslash escapes of an introspected string literal. */
+    unescapeDefault(val) {
+        const sqlEscapes = { 0: '\0', b: '\b', n: '\n', r: '\r', t: '\t', Z: '\x1a' };
+        return val.replace(/\\(.)/gs, (_, char) => sqlEscapes[char] ?? char);
     }
 }

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -330,10 +330,9 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return columnDefs.map(colDef => {
             const name = unquote(colDef);
             const result = { name };
-            // Find this column in the expression and extract modifiers
-            // Create a pattern that matches the column name (quoted or unquoted) followed by modifiers
+            // Match the column (quoted or unquoted) as a whole list item, so `id` never matches inside `author_id`
             const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            const colPattern = new RegExp(`"?${escapedName}"?\\s*([^,)]*?)(?:,|$)`, 'i');
+            const colPattern = new RegExp(`(?:^|,)\\s*"?${escapedName}"?(?=\\s|,|$)\\s*([^,)]*?)(?:,|$)`, 'i');
             const colMatch = columnsStr.match(colPattern);
             if (colMatch) {
                 const modifiers = colMatch[1];
@@ -1227,7 +1226,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         if (!defaultValue || typeof defaultValue !== 'string') {
             return super.normalizeDefaultValue(defaultValue, length, PostgreSqlSchemaHelper.DEFAULT_VALUES);
         }
-        const match = /^'(.*)'::(.*)$/.exec(defaultValue);
+        const match = /^'(.*)'::(.*)$/s.exec(defaultValue);
         if (match) {
             if (match[2] === 'integer') {
                 return +match[1];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.2.6-dev.8",
+  "version": "7.2.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.",
   "keywords": [
     "data-mapper",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "kysely": "0.29.6"
+    "kysely": "0.29.7"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.2.5"
+    "@mikro-orm/core": "^7.2.6"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.2.6-dev.8"
+    "@mikro-orm/core": "7.2.6"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/NativeQueryBuilder.d.ts

@@ -121,6 +121,8 @@ export declare class NativeQueryBuilder implements Subquery {
     lockMode(lockMode: LockMode, lockTables?: string[]): this;
     comment(comment: string | string[]): this;
     hintComment(comment: string | string[]): this;
+    /** Comments are interpolated verbatim, so a terminator or a `?` placeholder inside one would corrupt the query. */
+    private validateComments;
     setFlags(flags: Set<QueryFlag>): this;
     clear(clause: keyof Options): this;
     wrap(prefix: string, suffix: string): this;

package/query/NativeQueryBuilder.js

@@ -258,14 +258,23 @@ export class NativeQueryBuilder {
     }
     comment(comment) {
         this.options.comment ??= [];
-        this.options.comment.push(...Utils.asArray(comment));
+        this.options.comment.push(...this.validateComments(comment));
         return this;
     }
     hintComment(comment) {
         this.options.hintComment ??= [];
-        this.options.hintComment.push(...Utils.asArray(comment));
+        this.options.hintComment.push(...this.validateComments(comment));
         return this;
     }
+    /** Comments are interpolated verbatim, so a terminator or a `?` placeholder inside one would corrupt the query. */
+    validateComments(comment) {
+        const comments = Utils.asArray(comment);
+        const invalid = comments.find(c => c.includes('/*') || c.includes('*/') || c.includes('?'));
+        if (invalid != null) {
+            throw new Error(`Query comments cannot contain '/*', '*/' or '?', got: '${invalid}'`);
+        }
+        return comments;
+    }
     setFlags(flags) {
         this.options.flags = flags;
         return this;

package/query/ObjectCriteriaNode.js

@@ -57,6 +57,8 @@ export class ObjectCriteriaNode extends CriteriaNode {
                     // schema-less entities the schema is resolved dynamically and needs to be carried over
                     const fixedSchema = parentMeta.schema && parentMeta.schema !== '*';
                     const qb2 = qb.clone(true, fixedSchema ? undefined : ['schema']);
+                    // the payload was already converted when processing the parent query
+                    qb2.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
                     const joinAlias = qb2.getNextAlias(this.prop.targetMeta.class);
                     const sub = qb2
                         .from(parentMeta.class)

package/query/QueryBuilder.js

@@ -1157,8 +1157,9 @@ export class QueryBuilder {
         const hash = (data) => {
             return Utils.getPrimaryKeyHash(meta.primaryKeys.map(pk => data[pk]));
         };
+        const map = {};
         for await (const row of res) {
-            const mapped = this.driver.mapResult(row, meta, this.#state.populate, this);
+            const mapped = this.driver.mapResult(row, meta, this.#state.populate, this, map);
             if (!options.mergeResults || joinedProps.length === 0) {
                 yield this.mapResult(mapped, options.mapResults);
                 continue;
@@ -1568,6 +1569,19 @@ export class QueryBuilder {
             if (prop && [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
                 return;
             }
+            // the joined strategy selects by column name, which can collide with the name of another property
+            const shadowed = customAlias &&
+                prop &&
+                (prop.kind === ReferenceKind.EMBEDDED ||
+                    (customAlias.endsWith(`__${f}`) && (prop.persist === false || !prop.fieldNames.includes(f)))) &&
+                (this.#state.aliases[a]?.meta ?? this.mainAlias.meta).props.some(p => p !== prop &&
+                    p.persist !== false &&
+                    (p.kind !== ReferenceKind.EMBEDDED || p.object) &&
+                    p.fieldNames?.includes(f));
+            if (shadowed) {
+                ret.push(raw('?? as ??', [`${a}.${f}`, customAlias]));
+                return;
+            }
             if (prop?.persist === false && !prop.embedded && !prop.formula && type === 'where') {
                 return;
             }
@@ -1577,11 +1591,7 @@ export class QueryBuilder {
                 ret.push(getFieldName(aliased, customAlias));
                 return;
             }
-            // the joined strategy selects by column name, which can collide with an inline embedded property name
-            const shadowed = customAlias &&
-                prop?.kind === ReferenceKind.EMBEDDED &&
-                (this.#state.aliases[a]?.meta ?? this.mainAlias.meta).props.some(p => (p.kind !== ReferenceKind.EMBEDDED || p.object) && p.fieldNames?.includes(f));
-            if (prop?.kind === ReferenceKind.EMBEDDED && !shadowed) {
+            if (prop?.kind === ReferenceKind.EMBEDDED) {
                 if (customAlias) {
                     throw new Error(`Cannot use 'as ${customAlias}' alias on embedded property '${field}' because it expands to multiple columns. Alias individual fields instead (e.g. '${field}.propertyName as ${customAlias}').`);
                 }

package/schema/DatabaseTable.js

@@ -876,9 +876,9 @@ export class DatabaseTable {
             return +defaultValue;
         }
         // unquote string defaults if `raw = false`
-        const match = /^'(.*)'$/.exec('' + val);
+        const match = /^'(.*)'$/s.exec('' + val);
         if (!raw && match) {
-            return match[1];
+            return schemaHelper.unescapeDefault(match[1]);
         }
         return '' + val;
     }
@@ -924,6 +924,17 @@ export class DatabaseTable {
                 };
                 return [expand(rootProp, 1)];
             }
+            // object embedded property index, the JSON keys are the field names of the embedded properties
+            if (rootProp?.embeddable && rootProp.object && rootProp.embeddedProps[parts[1]]) {
+                let p = rootProp.embeddedProps[parts[1]];
+                let i = 2;
+                while (i < parts.length && p.embeddedProps?.[parts[i]]) {
+                    p = p.embeddedProps[parts[i]];
+                    i++;
+                }
+                // a path below the last embedded property targets plain JSON keys, kept as they are
+                return [[...p.embeddedPath, ...parts.slice(i)].join('.')];
+            }
             // json index, we need to rename the column only
             if (rootProp) {
                 return [prop.replace(root, rootProp.fieldNames[0])];

package/schema/SchemaComparator.js

@@ -866,16 +866,10 @@ export class SchemaComparator {
         if (cols1.length === 0 && cols2.length === 0) {
             return true;
         }
-        // If only one has column options, they don't match
-        if (cols1.length !== cols2.length) {
-            return false;
-        }
-        // Compare each column's options
-        // Note: We don't check c1.name !== c2.name because the indexes already have matching columnNames
-        // and the columns array is derived from those same column names
-        for (let i = 0; i < cols1.length; i++) {
-            const c1 = cols1[i];
-            const c2 = cols2[i];
+        // introspection may omit entries for columns with default options, so match them by name
+        for (const name of index1.columnNames) {
+            const c1 = cols1.find(c => c.name === name) ?? { name };
+            const c2 = cols2.find(c => c.name === name) ?? { name };
             const sort1 = c1.sort?.toUpperCase() ?? 'ASC';
             const sort2 = c2.sort?.toUpperCase() ?? 'ASC';
             if (sort1 !== sort2) {

package/schema/SchemaHelper.d.ts

@@ -163,6 +163,8 @@ export declare abstract class SchemaHelper {
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
+    /** Decodes the content of an introspected string literal, the inverse of `Platform.quoteDefaultValue()`. */
+    unescapeDefault(val: string): string;
     normalizeDefaultValue(defaultValue: string | RawQueryFragment, length?: number, defaultValues?: Dictionary<string[]>): string | number;
     getCreateDatabaseSQL(name: string): string;
     getDropDatabaseSQL(name: string): string;

package/schema/SchemaHelper.js

@@ -614,6 +614,8 @@ export class SchemaHelper {
         }
         if (useDefault) {
             // https://dev.mysql.com/doc/refman/9.0/en/data-type-defaults.html
+            // `tinytext`, `mediumtext`, `longblob` etc. follow the same rule as `text` and `blob`
+            const baseType = column.type.toLowerCase().replace(/^(tiny|medium|long)/, '');
             const needsExpression = [
                 'blob',
                 'text',
@@ -625,7 +627,7 @@ export class SchemaHelper {
                 'multilinestring',
                 'multipolygon',
                 'geometrycollection',
-            ].some(type => column.type.toLowerCase().startsWith(type));
+            ].some(type => baseType.startsWith(type));
             const defaultSql = needsExpression && !column.default.startsWith('(') ? `(${column.default})` : column.default;
             col.push(`default ${defaultSql}`);
         }
@@ -716,6 +718,10 @@ export class SchemaHelper {
             return ret;
         }, {});
     }
+    /** Decodes the content of an introspected string literal, the inverse of `Platform.quoteDefaultValue()`. */
+    unescapeDefault(val) {
+        return val.replaceAll("''", "'");
+    }
     normalizeDefaultValue(defaultValue, length, defaultValues = {}) {
         if (defaultValue == null) {
             return defaultValue;