@mikro-orm/sql 7.1.9-dev.0 → 7.1.9-dev.10

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -168,7 +168,7 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
             const fields = this.options.groupBy.map(field => this.quote(field));
             this.parts.push(`group by ${fields.join(', ')}`);
         }
-        if (this.options.having) {
+        if (this.options.having?.sql.trim()) {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }

package/dialects/oracledb/OracleNativeQueryBuilder.js

@@ -234,7 +234,7 @@ export class OracleNativeQueryBuilder extends NativeQueryBuilder {
             const fields = this.options.groupBy.map(field => this.quote(field));
             this.parts.push(`group by ${fields.join(', ')}`);
         }
-        if (this.options.having) {
+        if (this.options.having?.sql.trim()) {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -7,4 +7,7 @@ export declare class BaseSqliteConnection extends AbstractSqlConnection {
         skipOnConnect?: boolean;
     }): Promise<void>;
     protected attachDatabases(): Promise<void>;
+    /** Per-connection state, lost whenever the underlying connection is recreated, so it has to be replayed. */
+    protected getConnectionSetupSql(): Promise<string[]>;
+    private getAttachDatabasesSql;
 }

package/dialects/sqlite/BaseSqliteConnection.js

@@ -1,5 +1,6 @@
 import { CompiledQuery } from 'kysely';
 import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
+const FOREIGN_KEYS_PRAGMA = 'pragma foreign_keys = on';
 export class BaseSqliteConnection extends AbstractSqlConnection {
     createKyselyDialect(options) {
         throw new Error('No SQLite dialect configured. Pass a Kysely dialect via the `driverOptions` config option, ' +
@@ -7,19 +8,28 @@ export class BaseSqliteConnection extends AbstractSqlConnection {
     }
     async connect(options) {
         await super.connect(options);
-        await this.getClient().executeQuery(CompiledQuery.raw('pragma foreign_keys = on'));
+        await this.getClient().executeQuery(CompiledQuery.raw(FOREIGN_KEYS_PRAGMA));
         await this.attachDatabases();
     }
     async attachDatabases() {
+        for (const sql of await this.getAttachDatabasesSql()) {
+            await this.execute(sql);
+        }
+    }
+    /** Per-connection state, lost whenever the underlying connection is recreated, so it has to be replayed. */
+    async getConnectionSetupSql() {
+        return [FOREIGN_KEYS_PRAGMA, ...(await this.getAttachDatabasesSql())];
+    }
+    async getAttachDatabasesSql() {
         const attachDatabases = this.config.get('attachDatabases');
         if (!attachDatabases?.length) {
-            return;
+            return [];
         }
         const { fs } = await import('@mikro-orm/core/fs-utils');
         const baseDir = this.config.get('baseDir');
-        for (const db of attachDatabases) {
+        return attachDatabases.map(db => {
             const path = fs.absolutePath(db.path, baseDir);
-            await this.execute(`attach database '${path}' as ${this.platform.quoteIdentifier(db.name)}`);
-        }
+            return `attach database '${path}' as ${this.platform.quoteIdentifier(db.name)}`;
+        });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.9-dev.0",
+  "version": "7.1.9-dev.10",
   "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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.1.8"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.9-dev.0"
+    "@mikro-orm/core": "7.1.9-dev.10"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/NativeQueryBuilder.js

@@ -308,7 +308,7 @@ export class NativeQueryBuilder {
             const fields = this.options.groupBy.map(field => this.quote(field));
             this.parts.push(`group by ${fields.join(', ')}`);
         }
-        if (this.options.having) {
+        if (this.options.having?.sql.trim()) {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }

package/query/QueryBuilderHelper.js

@@ -414,7 +414,8 @@ export class QueryBuilderHelper {
             }
             if (k === '$not') {
                 const res = this._appendQueryCondition(type, cond[k]);
-                parts.push(`not (${res.sql})`);
+                // negating a vacuously true condition (e.g. an empty `$and`) matches nothing
+                parts.push(res.sql ? `not (${res.sql})` : '1 = 0');
                 res.params.forEach(p => params.push(p));
                 continue;
             }
@@ -785,6 +786,10 @@ export class QueryBuilderHelper {
     appendGroupCondition(type, operator, subCondition) {
         const parts = [];
         const params = [];
+        // an empty disjunction is false, same as `$in: []`, while an empty conjunction is vacuously true
+        if (operator === '$or' && subCondition.length === 0) {
+            return { sql: '1 = 0', params };
+        }
         // single sub-condition can be ignored to reduce nesting of parens
         if (subCondition.length === 1 || operator === '$and') {
             for (const sub of subCondition) {

package/schema/SchemaComparator.js

@@ -897,9 +897,13 @@ export class SchemaComparator {
                 // lookbehind: only strip a real charset introducer, never an underscore inside a literal like 'a_b'
                 ?.replace(/(?<![\w'])_\w+'(.*?)'/g, '$1')
                 .replace(/!=/g, '<>')
-                .replace(/in\s*\((.*?)\)/gi, '= any (array[$1])')
+                // `\b` keeps this from firing inside identifiers like `min(...)`
+                .replace(/\bin\s*\((.*?)\)/gi, '= any (array[$1])')
                 // MySQL normalizes count(*) to count(0)
                 .replace(/\bcount\s*\(\s*0\s*\)/gi, 'count(*)')
+                // multi word type names in casts, the generic `::\w+` below only covers single word ones
+                // the precision is kept, so `timestamptz(3)` and `timestamp(3) with time zone` leave the same residue
+                .replace(/::\s*(?:character\s+varying|bit\s+varying|double\s+precision|(?:timestamp|time)\b(\s*\(\d+\))?(?:\s+with(?:out)?\s+time\s+zone)?)/gi, '$1')
                 // Remove quotes first so we can process identifiers
                 .replace(/['"`]/g, '')
                 // MySQL adds table/alias prefixes to columns (e.g., a.name or table_name.column vs just column)
@@ -907,6 +911,10 @@ export class SchemaComparator {
                 .replace(/\b\w+\.(\w+)/g, '$1')
                 // Normalize JOIN syntax: inner join -> join (equivalent in SQL)
                 .replace(/\binner\s+join\b/gi, 'join')
+                // PostgreSQL names an unaliased bare function call after the function itself,
+                // so `max(created_at)` comes back as `max(created_at) AS max`
+                // the lookahead skips table function column alias lists like `unnest(a) AS unnest(c)`, which are meaningful
+                .replace(/\b(\w+)\s*\(((?:[^()]|\([^()]*\))*)\)\s+as\s+\1\b(?!\s*\()/gi, '$1($2)')
                 // Remove redundant column aliases like `title AS title` -> `title`
                 .replace(/\b(\w+)\s+as\s+\1\b/gi, '$1')
                 // Remove AS keyword (optional in SQL, MySQL may add/remove it)