@mikro-orm/sql 7.1.12-dev.1 → 7.1.12-dev.11

package/SqlEntityManager.js

@@ -75,8 +75,7 @@ export class SqlEntityManager extends EntityManager {
      */
     async countBy(entityName, groupBy, options = {}) {
         const em = this.getContext(false);
-        options = { ...options };
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         const meta = em.getMetadata().find(entityName);
         const fields = Utils.asArray(groupBy);
         const { where: rawWhere, ...countOptions } = options;

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -69,6 +69,8 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
     /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
     dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /** Flattens `;\n` inside the dollar-quoted blocks of a raw DDL expression, which are not statement boundaries. */
+    private flattenDollarQuotedBodies;
     createRoutine(routine: SqlRoutineDef): string;
     dropRoutine(routine: SqlRoutineDef): string;
     getAllRoutines(connection: AbstractSqlConnection, schemas?: string[]): Promise<SqlRoutineDef[]>;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -3,6 +3,8 @@ import { SchemaHelper, stripStatementNewlines } from '../../schema/SchemaHelper.
 import { normalizePartitionBound, normalizePartitionDefinition } from '../../schema/partitioning.js';
 /** PostGIS system views that should be automatically ignored */
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
+/** Dollar-quote delimiter, e.g. `$$` or `$body$`, captured so `split` keeps it. */
+const DOLLAR_QUOTE_TAG = /(\$(?:[A-Za-z_]\w*)?\$)/;
 export class PostgreSqlSchemaHelper extends SchemaHelper {
     static DEFAULT_VALUES = {
         'now()': ['now()', 'current_timestamp'],
@@ -505,7 +507,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
     /** Generates SQL to create a PostgreSQL trigger and its associated function. */
     createTrigger(table, trigger) {
         if (trigger.expression) {
-            return trigger.expression;
+            return this.flattenDollarQuotedBodies(trigger.expression);
         }
         const timing = trigger.timing.toUpperCase();
         const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
@@ -523,9 +525,24 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
         return `drop trigger if exists ${triggerName} on ${table.getQuotedName()};\ndrop function if exists ${fnName}()`;
     }
+    /** Flattens `;\n` inside the dollar-quoted blocks of a raw DDL expression, which are not statement boundaries. */
+    flattenDollarQuotedBodies(ddl) {
+        let openTag = '';
+        return ddl
+            .split(DOLLAR_QUOTE_TAG)
+            .map((part, i) => {
+            // the capture group puts the delimiters on the odd indexes
+            if (i % 2 === 1) {
+                openTag = openTag === part ? '' : openTag || part;
+                return part;
+            }
+            return openTag ? stripStatementNewlines(part) : part;
+        })
+            .join('');
+    }
     createRoutine(routine) {
         if (routine.expression) {
-            return routine.expression;
+            return this.flattenDollarQuotedBodies(routine.expression);
         }
         const qualifiedName = this.qualifiedRoutineName(routine);
         const params = this.formatRoutineParams(routine);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.12-dev.1",
+  "version": "7.1.12-dev.11",
   "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.4"
+    "kysely": "0.29.5"
   },
   "devDependencies": {
     "@mikro-orm/core": "^7.1.11"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.12-dev.1"
+    "@mikro-orm/core": "7.1.12-dev.11"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilder.d.ts

@@ -152,11 +152,10 @@ type ContextFilterKeys<Context> = {
 type RawFilterKeys<RawAliases extends string> = {
     [K in RawAliases]?: AliasedFilterValue;
 };
-type NestedFilterCondition<Entity, RootAlias extends string, Context, RawAliases extends string> = ObjectQuery<Entity> & (IsNever<RootAlias> extends true ? {} : string extends RootAlias ? {} : RootAliasFilterKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextFilterKeys<Context>) & (IsNever<RawAliases> extends true ? {} : string extends RawAliases ? {} : RawFilterKeys<RawAliases>);
 type GroupOperators<RootAlias extends string, Context, Entity, RawAliases extends string> = {
-    $and?: NestedFilterCondition<Entity, RootAlias, Context, RawAliases>[];
-    $or?: NestedFilterCondition<Entity, RootAlias, Context, RawAliases>[];
-    $not?: NestedFilterCondition<Entity, RootAlias, Context, RawAliases>;
+    $and?: QBFilterQuery<Entity, RootAlias, Context, RawAliases>[];
+    $or?: QBFilterQuery<Entity, RootAlias, Context, RawAliases>[];
+    $not?: QBFilterQuery<Entity, RootAlias, Context, RawAliases>;
 };
 export type AliasedFilterCondition<RootAlias extends string, Context, Entity, RawAliases extends string = never> = (IsNever<RootAlias> extends true ? {} : string extends RootAlias ? {} : RootAliasFilterKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextFilterKeys<Context>) & (IsNever<RawAliases> extends true ? {} : string extends RawAliases ? {} : RawFilterKeys<RawAliases>) & GroupOperators<RootAlias, Context, Entity, RawAliases>;
 export type QBFilterQuery<Entity, RootAlias extends string = never, Context = never, RawAliases extends string = never> = FilterObject<Entity> & AliasedFilterCondition<RootAlias, Context, Entity, RawAliases>;

package/schema/DatabaseTable.js

@@ -1030,8 +1030,12 @@ export class DatabaseTable {
             // mysql stores decimal defaults padded to scale (`0` → `0.00`); collapse to canonical numeric form
             // so the metadata-side (`0`) and introspection-side (`0.00`) snapshots agree
             let defaultValue = c.default ?? null;
-            if (defaultValue != null && c.mappedType instanceof DecimalType && Number.isFinite(+defaultValue)) {
-                defaultValue = this.#platform.formatDecimal(defaultValue, c.scale).toString();
+            if (defaultValue != null && c.mappedType instanceof DecimalType) {
+                // string defaults like `default: '0.00'` are quoted in metadata, so strip the quotes first
+                const unquoted = defaultValue.replace(/^'(.*)'$/, '$1');
+                if (Number.isFinite(+unquoted)) {
+                    defaultValue = this.#platform.formatDecimal(unquoted, c.scale).toString();
+                }
             }
             const normalized = {
                 name: c.name,

package/schema/SchemaComparator.d.ts

@@ -89,6 +89,7 @@ export declare class SchemaComparator {
     private diffViewExpression;
     private diffTrigger;
     parseJsonDefault(defaultValue?: string | null): Dictionary | string | null;
+    private parseDecimalDefault;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;
     private log;

package/schema/SchemaComparator.js

@@ -993,6 +993,10 @@ export class SchemaComparator {
         const val = defaultValue.replace(/^(_\w+\\)?'(.*?)\\?'$/, '$2').replace(/^\(?'(.*?)'\)?$/, '$1');
         return parseJsonSafe(val);
     }
+    parseDecimalDefault(defaultValue) {
+        const value = +('' + defaultValue).replace(/^'(.+)'$/, '$1');
+        return Number.isFinite(value) ? value : null;
+    }
     hasSameDefaultValue(from, to) {
         if (from.default == null ||
             from.default.toString().toLowerCase() === 'null' ||
@@ -1018,10 +1022,15 @@ export class SchemaComparator {
             const defaultValueTo = to.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');
             return defaultValueFrom === defaultValueTo;
         }
-        // mysql stores decimal defaults padded to scale (`0` → `0.00`); compare numerically so the
-        // entity-side raw literal and the introspected padded form don't churn the no-op migration
-        if (to.mappedType instanceof DecimalType && Number.isFinite(+from.default) && Number.isFinite(+to.default)) {
-            return (this.#platform.formatDecimal(from.default, to.scale) === this.#platform.formatDecimal(to.default, to.scale));
+        // mysql pads decimal defaults to scale (`0` → `0.00`) and postgres reports them unquoted
+        // while metadata keeps them quoted; compare numerically so neither churns a no-op migration
+        if (to.mappedType instanceof DecimalType) {
+            const defaultValueFrom = this.parseDecimalDefault(from.default);
+            const defaultValueTo = this.parseDecimalDefault(to.default);
+            if (defaultValueFrom != null && defaultValueTo != null) {
+                return (this.#platform.formatDecimal(defaultValueFrom, to.scale) ===
+                    this.#platform.formatDecimal(defaultValueTo, to.scale));
+            }
         }
         if (from.default && to.default) {
             return from.default.toString().toLowerCase() === to.default.toString().toLowerCase();