@mikro-orm/sql 7.0.0-rc.1 → 7.0.0-rc.3

package/PivotCollectionPersister.js

@@ -12,7 +12,7 @@ class InsertStatement {
     }
     getData() {
         const data = {};
-        this.keys.forEach((key, idx) => data[key] = this.data[idx]);
+        this.keys.forEach((key, idx) => (data[key] = this.data[idx]));
         return data;
     }
 }
@@ -28,7 +28,7 @@ class DeleteStatement {
     }
     getCondition() {
         const cond = {};
-        this.keys.forEach((key, idx) => cond[key] = this.cond[idx]);
+        this.keys.forEach((key, idx) => (cond[key] = this.cond[idx]));
         return cond;
     }
 }

package/SqlEntityManager.d.ts

@@ -4,7 +4,7 @@ import type { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 import type { QueryBuilder } from './query/QueryBuilder.js';
 import type { SqlEntityRepository } from './SqlEntityRepository.js';
 import type { Kysely } from 'kysely';
-import type { InferKyselyDB } from './typings.js';
+import type { InferClassEntityDB, InferKyselyDB } from './typings.js';
 import { type MikroKyselyPluginOptions } from './plugin/index.js';
 export interface GetKyselyOptions extends MikroKyselyPluginOptions {
     type?: ConnectionType;
@@ -20,14 +20,15 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias, never, never, never, "*">;
+    qb<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias, never, never, never, "*", {}>;
     /**
      * Returns configured Kysely instance.
      */
-    getKysely<TDB = undefined, TOptions extends GetKyselyOptions = GetKyselyOptions>(options?: TOptions): Kysely<TDB extends undefined ? InferKyselyDB<EntitiesFromManager<this>, TOptions> : TDB>;
+    getKysely<TDB = undefined, TOptions extends GetKyselyOptions = GetKyselyOptions>(options?: TOptions): Kysely<TDB extends undefined ? InferKyselyDB<EntitiesFromManager<this>, TOptions> & InferClassEntityDB<AllEntitiesFromManager<this>, TOptions> : TDB>;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
     getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<Entity>): FilterQuery<Entity>;
 }
-type EntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends any[] ? (Extract<NonNullable<TEntityManager['~entities']>[number], EntitySchemaWithMeta>) : never;
+type EntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends any[] ? Extract<NonNullable<TEntityManager['~entities']>[number], EntitySchemaWithMeta> : never;
+type AllEntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends any[] ? NonNullable<TEntityManager['~entities']>[number] : never;
 export {};

package/SqlEntityManager.js

@@ -22,11 +22,11 @@ export class SqlEntityManager extends EntityManager {
      */
     getKysely(options = {}) {
         let kysely = this.getConnection(options.type).getClient();
-        if (options.columnNamingStrategy != null
-            || options.tableNamingStrategy != null
-            || options.processOnCreateHooks != null
-            || options.processOnUpdateHooks != null
-            || options.convertValues != null) {
+        if (options.columnNamingStrategy != null ||
+            options.tableNamingStrategy != null ||
+            options.processOnCreateHooks != null ||
+            options.processOnUpdateHooks != null ||
+            options.convertValues != null) {
             kysely = kysely.withPlugin(new MikroKyselyPlugin(this, options));
         }
         return kysely;

package/dialects/mssql/MsSqlNativeQueryBuilder.d.ts

@@ -11,4 +11,6 @@ export declare class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
     protected compileSelect(): void;
     protected addLockClause(): void;
     protected compileTruncate(): void;
+    /** MSSQL has no RECURSIVE keyword — CTEs are implicitly recursive. */
+    protected getCteKeyword(_hasRecursive: boolean): string;
 }

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -19,6 +19,7 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         if (this.options.comment) {
             this.parts.push(...this.options.comment.map(comment => `/* ${comment} */`));
         }
+        this.compileCtes();
         if (this.options.onConflict && !Utils.isEmpty(Utils.asArray(this.options.data)[0])) {
             this.compileUpsert();
         }
@@ -77,9 +78,7 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
             return { prefix: '', suffix: '' };
         }
         const returningFields = this.options.returning;
-        const selections = returningFields
-            .map(field => `[t].${this.platform.quoteIdentifier(field)}`)
-            .join(',');
+        const selections = returningFields.map(field => `[t].${this.platform.quoteIdentifier(field)}`).join(',');
         return {
             prefix: `select top(0) ${selections} into #out from ${this.getTableName()} as t left join ${this.getTableName()} on 0 = 1;`,
             suffix: `select ${selections} from #out as t; drop table #out`,
@@ -181,7 +180,8 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         }
     }
     addLockClause() {
-        if (!this.options.lockMode || ![LockMode.PESSIMISTIC_READ, LockMode.PESSIMISTIC_WRITE].includes(this.options.lockMode)) {
+        if (!this.options.lockMode ||
+            ![LockMode.PESSIMISTIC_READ, LockMode.PESSIMISTIC_WRITE].includes(this.options.lockMode)) {
             return;
         }
         const map = {
@@ -197,4 +197,8 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         const sql = `delete from ${tableName}; declare @count int = case @@rowcount when 0 then 1 else 0 end; dbcc checkident ('${tableName.replace(/[[\]]/g, '')}', reseed, @count)`;
         this.parts.push(sql);
     }
+    /** MSSQL has no RECURSIVE keyword — CTEs are implicitly recursive. */
+    getCteKeyword(_hasRecursive) {
+        return 'with';
+    }
 }

package/dialects/mysql/BaseMySqlPlatform.js

@@ -44,8 +44,7 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
         return JSON.stringify(value);
     }
     getJsonIndexDefinition(index) {
-        return index.columnNames
-            .map(column => {
+        return index.columnNames.map(column => {
             if (!column.includes('.')) {
                 return column;
             }

package/dialects/mysql/MySqlSchemaHelper.js

@@ -89,11 +89,13 @@ export class MySqlSchemaHelper extends SchemaHelper {
             };
             // Capture column options (prefix length, sort order)
             if (index.sub_part != null || index.sort_order === 'D') {
-                indexDef.columns = [{
+                indexDef.columns = [
+                    {
                         name: index.column_name,
                         ...(index.sub_part != null && { length: index.sub_part }),
                         ...(index.sort_order === 'D' && { sort: 'DESC' }),
-                    }];
+                    },
+                ];
             }
             // Capture index type for fulltext and spatial indexes
             if (index.index_type === 'FULLTEXT') {
@@ -149,7 +151,8 @@ export class MySqlSchemaHelper extends SchemaHelper {
      */
     getIndexColumns(index) {
         if (index.columns?.length) {
-            return index.columns.map(col => {
+            return index.columns
+                .map(col => {
                 const quotedName = this.quote(col.name);
                 // MySQL supports collation via expression: (column_name COLLATE collation_name)
                 // When collation is specified, wrap in parentheses as an expression
@@ -173,7 +176,8 @@ export class MySqlSchemaHelper extends SchemaHelper {
                     colDef += ` ${col.sort}`;
                 }
                 return colDef;
-            }).join(', ');
+            })
+                .join(', ');
         }
         return index.columnNames.map(c => this.quote(c)).join(', ');
     }
@@ -205,20 +209,24 @@ export class MySqlSchemaHelper extends SchemaHelper {
       from information_schema.columns where table_schema = database() and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))})
       order by ordinal_position`;
         const allColumns = await connection.execute(sql);
-        const str = (val) => val != null ? '' + val : val;
+        const str = (val) => (val != null ? '' + val : val);
         const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
         const ret = {};
         for (const col of allColumns) {
             const mappedType = this.platform.getMappedType(col.column_type);
-            const defaultValue = str(this.normalizeDefaultValue((mappedType.compareAsType() === 'boolean' && ['0', '1'].includes(col.column_default))
+            const defaultValue = str(this.normalizeDefaultValue(mappedType.compareAsType() === 'boolean' && ['0', '1'].includes(col.column_default)
                 ? ['false', 'true'][+col.column_default]
                 : col.column_default, col.length));
             const key = this.getTableKey(col);
-            const generated = col.generation_expression ? `(${col.generation_expression.replaceAll(`\\'`, `'`)}) ${col.extra.match(/stored generated/i) ? 'stored' : 'virtual'}` : undefined;
+            const generated = col.generation_expression
+                ? `(${col.generation_expression.replaceAll(`\\'`, `'`)}) ${col.extra.match(/stored generated/i) ? 'stored' : 'virtual'}`
+                : undefined;
             ret[key] ??= [];
             ret[key].push({
                 name: col.column_name,
-                type: this.platform.isNumericColumn(mappedType) ? col.column_type.replace(/ unsigned$/, '').replace(/\(\d+\)$/, '') : col.column_type,
+                type: this.platform.isNumericColumn(mappedType)
+                    ? col.column_type.replace(/ unsigned$/, '').replace(/\(\d+\)$/, '')
+                    : col.column_type,
                 mappedType,
                 unsigned: col.column_type.endsWith(' unsigned'),
                 length: col.length,
@@ -328,7 +336,10 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const enums = await connection.execute(sql);
         return enums.reduce((o, item) => {
             o[item.table_name] ??= {};
-            o[item.table_name][item.column_name] = item.column_type.match(/enum\((.*)\)/)[1].split(',').map((item) => item.match(/'(.*)'/)[1]);
+            o[item.table_name][item.column_name] = item.column_type
+                .match(/enum\((.*)\)/)[1]
+                .split(',')
+                .map((item) => item.match(/'(.*)'/)[1]);
             return o;
         }, {});
     }
@@ -338,7 +349,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         const sql = `select 1 from information_schema.tables where table_name = 'CHECK_CONSTRAINTS' and table_schema = 'information_schema'`;
         const res = await connection.execute(sql);
-        return this._cache.supportsCheckConstraints = res.length > 0;
+        return (this._cache.supportsCheckConstraints = res.length > 0);
     }
     getChecksSQL(tables) {
         return `select cc.constraint_schema as table_schema, tc.table_name as table_name, cc.constraint_name as name, cc.check_clause as expression

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -113,8 +113,10 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }
     getMappedType(type) {
         switch (this.extractSimpleType(type)) {
-            case 'tsvector': return Type.getType(FullTextType);
-            default: return super.getMappedType(type);
+            case 'tsvector':
+                return Type.getType(FullTextType);
+            default:
+                return super.getMappedType(type);
         }
     }
     getRegExpOperator(val, flags) {
@@ -132,7 +134,7 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         return { $re: val.source };
     }
     isBigIntProperty(prop) {
-        return super.isBigIntProperty(prop) || (['bigserial', 'int8'].includes(prop.columnTypes?.[0]));
+        return super.isBigIntProperty(prop) || ['bigserial', 'int8'].includes(prop.columnTypes?.[0]);
     }
     getArrayDeclarationSQL() {
         return 'text[]';
@@ -166,7 +168,7 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         return ['begin'];
     }
     marshallArray(values) {
-        const quote = (v) => v === '' || v.match(/["{},\\]/) ? JSON.stringify(v) : v;
+        const quote = (v) => (v === '' || v.match(/["{},\\]/) ? JSON.stringify(v) : v);
         return `{${values.map(v => quote('' + v)).join(',')}}`;
     }
     /* v8 ignore next */
@@ -174,7 +176,10 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         if (value === '{}') {
             return [];
         }
-        return value.substring(1, value.length - 1).split(',').map(v => {
+        return value
+            .substring(1, value.length - 1)
+            .split(',')
+            .map(v => {
             if (v === `""`) {
                 return '';
             }
@@ -218,7 +223,8 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         const cast = (key) => raw(type in types ? `(${key})::${types[type]}` : key);
         let lastOperator = '->>';
         // force `->` for operator payloads with array values
-        if (Utils.isPlainObject(value) && Object.keys(value).every(key => ARRAY_OPERATORS.includes(key) && Array.isArray(value[key]))) {
+        if (Utils.isPlainObject(value) &&
+            Object.keys(value).every(key => ARRAY_OPERATORS.includes(key) && Array.isArray(value[key]))) {
             lastOperator = '->';
         }
         if (path.length === 0) {
@@ -227,8 +233,7 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         return cast(`${root}->${path.map(a => this.quoteValue(a)).join('->')}${lastOperator}'${last}'`);
     }
     getJsonIndexDefinition(index) {
-        return index.columnNames
-            .map(column => {
+        return index.columnNames.map(column => {
             if (!column.includes('.')) {
                 return column;
             }
@@ -286,26 +291,26 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     getDefaultMappedType(type) {
         const normalizedType = this.extractSimpleType(type);
         const map = {
-            'int2': 'smallint',
-            'smallserial': 'smallint',
-            'int': 'integer',
-            'int4': 'integer',
-            'serial': 'integer',
-            'serial4': 'integer',
-            'int8': 'bigint',
-            'bigserial': 'bigint',
-            'serial8': 'bigint',
-            'numeric': 'decimal',
-            'bool': 'boolean',
-            'real': 'float',
-            'float4': 'float',
-            'float8': 'double',
-            'timestamp': 'datetime',
-            'timestamptz': 'datetime',
-            'bytea': 'blob',
-            'jsonb': 'json',
+            int2: 'smallint',
+            smallserial: 'smallint',
+            int: 'integer',
+            int4: 'integer',
+            serial: 'integer',
+            serial4: 'integer',
+            int8: 'bigint',
+            bigserial: 'bigint',
+            serial8: 'bigint',
+            numeric: 'decimal',
+            bool: 'boolean',
+            real: 'float',
+            float4: 'float',
+            float8: 'double',
+            timestamp: 'datetime',
+            timestamptz: 'datetime',
+            bytea: 'blob',
+            jsonb: 'json',
             'character varying': 'varchar',
-            'bpchar': 'character',
+            bpchar: 'character',
         };
         return super.getDefaultMappedType(map[normalizedType] ?? type);
     }
@@ -339,9 +344,12 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
      */
     castColumn(prop) {
         switch (prop?.columnTypes?.[0]) {
-            case this.getUuidTypeDeclarationSQL({}): return '::text';
-            case this.getBooleanTypeDeclarationSQL(): return '::int';
-            default: return '';
+            case this.getUuidTypeDeclarationSQL({}):
+                return '::text';
+            case this.getBooleanTypeDeclarationSQL():
+                return '::int';
+            default:
+                return '';
         }
     }
     getDefaultClientUrl() {

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -1,4 +1,4 @@
-import { DeferMode, EnumType, Type, Utils } from '@mikro-orm/core';
+import { DeferMode, EnumType, Type, Utils, } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 /** PostGIS system views that should be automatically ignored */
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
@@ -22,24 +22,24 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return `create database ${name}`;
     }
     getListTablesSQL() {
-        return `select table_name, table_schema as schema_name, `
-            + `(select pg_catalog.obj_description(c.oid) from pg_catalog.pg_class c
-          where c.oid = (select ('"' || table_schema || '"."' || table_name || '"')::regclass::oid) and c.relname = table_name) as table_comment `
-            + `from information_schema.tables `
-            + `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} `
-            + `and table_name != 'geometry_columns' and table_name != 'spatial_ref_sys' and table_type != 'VIEW' `
-            + `and table_name not in (select inhrelid::regclass::text from pg_inherits) `
-            + `order by table_name`;
+        return (`select table_name, table_schema as schema_name, ` +
+            `(select pg_catalog.obj_description(c.oid) from pg_catalog.pg_class c
+          where c.oid = (select ('"' || table_schema || '"."' || table_name || '"')::regclass::oid) and c.relname = table_name) as table_comment ` +
+            `from information_schema.tables ` +
+            `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} ` +
+            `and table_name != 'geometry_columns' and table_name != 'spatial_ref_sys' and table_type != 'VIEW' ` +
+            `and table_name not in (select inhrelid::regclass::text from pg_inherits) ` +
+            `order by table_name`);
     }
     getIgnoredViewsCondition() {
         return POSTGIS_VIEWS.map(v => `table_name != '${v}'`).join(' and ');
     }
     getListViewsSQL() {
-        return `select table_name as view_name, table_schema as schema_name, view_definition `
-            + `from information_schema.views `
-            + `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} `
-            + `and ${this.getIgnoredViewsCondition()} `
-            + `order by table_name`;
+        return (`select table_name as view_name, table_schema as schema_name, view_definition ` +
+            `from information_schema.views ` +
+            `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} ` +
+            `and ${this.getIgnoredViewsCondition()} ` +
+            `order by table_name`);
     }
     async loadViews(schema, connection) {
         const views = await connection.execute(this.getListViewsSQL());
@@ -51,10 +51,10 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
     }
     getListMaterializedViewsSQL() {
-        return `select matviewname as view_name, schemaname as schema_name, definition as view_definition `
-            + `from pg_matviews `
-            + `where ${this.getIgnoredNamespacesConditionSQL('schemaname')} `
-            + `order by matviewname`;
+        return (`select matviewname as view_name, schemaname as schema_name, definition as view_definition ` +
+            `from pg_matviews ` +
+            `where ${this.getIgnoredNamespacesConditionSQL('schemaname')} ` +
+            `order by matviewname`);
     }
     async loadMaterializedViews(schema, connection, schemaName) {
         const views = await connection.execute(this.getListMaterializedViewsSQL());
@@ -78,9 +78,9 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return `refresh materialized view${concurrent} ${this.quote(this.getTableName(name, schema))}`;
     }
     async getNamespaces(connection) {
-        const sql = `select schema_name from information_schema.schemata `
-            + `where ${this.getIgnoredNamespacesConditionSQL()} `
-            + `order by schema_name`;
+        const sql = `select schema_name from information_schema.schemata ` +
+            `where ${this.getIgnoredNamespacesConditionSQL()} ` +
+            `order by schema_name`;
         const res = await connection.execute(sql);
         return res.map(row => row.schema_name);
     }
@@ -90,13 +90,11 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             'tiger',
             'topology',
             /* v8 ignore next */
-            ...this.platform.getConfig().get('schemaGenerator').ignoreSchema ?? [],
-        ].map(s => this.platform.quoteValue(s)).join(', ');
-        const ignoredPrefixes = [
-            'pg_',
-            'crdb_',
-            '_timescaledb_',
-        ].map(p => `"${column}" not like '${p}%'`).join(' and ');
+            ...(this.platform.getConfig().get('schemaGenerator').ignoreSchema ?? []),
+        ]
+            .map(s => this.platform.quoteValue(s))
+            .join(', ');
+        const ignoredPrefixes = ['pg_', 'crdb_', '_timescaledb_'].map(p => `"${column}" not like '${p}%'`).join(' and ');
         return `${ignoredPrefixes} and "${column}" not in (${ignored})`;
     }
     async loadInformationSchema(schema, connection, tables, schemas) {
@@ -130,9 +128,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             const key = this.getTableKey(index);
             // Extract INCLUDE columns from expression first, to filter them from key columns
             const includeMatch = index.expression?.match(/include\s*\(([^)]+)\)/i);
-            const includeColumns = includeMatch
-                ? includeMatch[1].split(',').map((col) => unquote(col.trim()))
-                : [];
+            const includeColumns = includeMatch ? includeMatch[1].split(',').map((col) => unquote(col.trim())) : [];
             // Filter out INCLUDE columns from the column definitions to get only key columns
             const keyColumnDefs = index.index_def.filter((col) => !includeColumns.includes(unquote(col)));
             // Parse sort order and NULLS ordering from the full expression
@@ -268,17 +264,18 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_schema = ${this.platform.quoteValue(schema)} and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}))`).join(' or ')})
       order by ordinal_position`;
         const allColumns = await connection.execute(sql);
-        const str = (val) => val != null ? '' + val : val;
+        const str = (val) => (val != null ? '' + val : val);
         const ret = {};
         for (const col of allColumns) {
             const mappedType = connection.getPlatform().getMappedType(col.data_type);
-            const increments = (col.column_default?.includes('nextval') || col.is_identity === 'YES') && connection.getPlatform().isNumericColumn(mappedType);
+            const increments = (col.column_default?.includes('nextval') || col.is_identity === 'YES') &&
+                connection.getPlatform().isNumericColumn(mappedType);
             const key = this.getTableKey(col);
             ret[key] ??= [];
-            let type = col.data_type.toLowerCase() === 'array'
-                ? col.udt_name.replace(/^_(.*)$/, '$1[]')
-                : col.udt_name;
-            if (col.data_type === 'USER-DEFINED' && col.udt_schema && col.udt_schema !== this.platform.getDefaultSchemaName()) {
+            let type = col.data_type.toLowerCase() === 'array' ? col.udt_name.replace(/^_(.*)$/, '$1[]') : col.udt_name;
+            if (col.data_type === 'USER-DEFINED' &&
+                col.udt_schema &&
+                col.udt_schema !== this.platform.getDefaultSchemaName()) {
                 type = `${col.udt_schema}.${type}`;
             }
             if (type === 'bpchar') {
@@ -305,7 +302,13 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 default: str(this.normalizeDefaultValue(col.column_default, col.length)),
                 unsigned: increments,
                 autoincrement: increments,
-                generated: col.is_identity === 'YES' ? (col.identity_generation === 'BY DEFAULT' ? 'by default as identity' : 'identity') : (col.generation_expression ? col.generation_expression + ' stored' : undefined),
+                generated: col.is_identity === 'YES'
+                    ? col.identity_generation === 'BY DEFAULT'
+                        ? 'by default as identity'
+                        : 'identity'
+                    : col.generation_expression
+                        ? col.generation_expression + ' stored'
+                        : undefined,
                 comment: col.column_comment,
             };
             if (nativeEnums?.[column.type]) {
@@ -321,10 +324,16 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const sql = this.getChecksSQL(tablesBySchemas);
         const allChecks = await connection.execute(sql);
         const ret = {};
+        const seen = new Set();
         for (const check of allChecks) {
             const key = this.getTableKey(check);
+            const dedupeKey = `${key}:${check.name}`;
+            if (seen.has(dedupeKey)) {
+                continue;
+            }
+            seen.add(dedupeKey);
             ret[key] ??= [];
-            const m = check.expression.match(/^check \(\((.*)\)\)$/i);
+            const m = check.expression.match(/^check \(\((.*)\)\)$/is);
             const def = m?.[1].replace(/\((.*?)\)::\w+/g, '$1');
             ret[key].push({
                 name: check.name,
@@ -359,12 +368,17 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             }
             /* v8 ignore next */
             switch (value) {
-                case 'r': return 'RESTRICT';
-                case 'c': return 'CASCADE';
-                case 'n': return 'SET NULL';
-                case 'd': return 'SET DEFAULT';
+                case 'r':
+                    return 'RESTRICT';
+                case 'c':
+                    return 'CASCADE';
+                case 'n':
+                    return 'SET NULL';
+                case 'd':
+                    return 'SET DEFAULT';
                 case 'a':
-                default: return 'NO ACTION';
+                default:
+                    return 'NO ACTION';
             }
         }
         for (const fk of allFks) {
@@ -645,7 +659,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
      */
     getIndexColumns(index) {
         if (index.columns?.length) {
-            return index.columns.map(col => {
+            return index.columns
+                .map(col => {
                 let colDef = this.quote(col.name);
                 // PostgreSQL supports collation with double quotes
                 if (col.collation) {
@@ -660,7 +675,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                     colDef += ` nulls ${col.nulls}`;
                 }
                 return colDef;
-            }).join(', ');
+            })
+                .join(', ');
         }
         return index.columnNames.map(c => this.quote(c)).join(', ');
     }
@@ -702,7 +718,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       from pg_constraint pgc
       join pg_namespace nsp on nsp.oid = pgc.connamespace
       join pg_class cls on pgc.conrelid = cls.oid
-      join information_schema.constraint_column_usage ccu on pgc.conname = ccu.constraint_name and nsp.nspname = ccu.constraint_schema
+      join information_schema.constraint_column_usage ccu on pgc.conname = ccu.constraint_name and nsp.nspname = ccu.constraint_schema and cls.relname = ccu.table_name
       where contype = 'c' and (${[...tablesBySchemas.entries()].map(([schema, tables]) => `ccu.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and ccu.table_schema = ${this.platform.quoteValue(schema)}`).join(' or ')})
       order by pgc.conname`;
     }

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -1,5 +1,8 @@
+import { type Dialect } from 'kysely';
+import type { Dictionary } from '@mikro-orm/core';
 import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
-export declare abstract class BaseSqliteConnection extends AbstractSqlConnection {
+export declare class BaseSqliteConnection extends AbstractSqlConnection {
+    createKyselyDialect(options: Dictionary): Dialect;
     connect(options?: {
         skipOnConnect?: boolean;
     }): Promise<void>;

package/dialects/sqlite/BaseSqliteConnection.js

@@ -1,6 +1,10 @@
 import { CompiledQuery } from 'kysely';
 import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 export class BaseSqliteConnection extends AbstractSqlConnection {
+    createKyselyDialect(options) {
+        throw new Error('No SQLite dialect configured. Pass a Kysely dialect via the `driverOptions` config option, ' +
+            'e.g. `new NodeSqliteDialect(...)` for node:sqlite or a custom dialect for other libraries.');
+    }
     async connect(options) {
         await super.connect(options);
         await this.getClient().executeQuery(CompiledQuery.raw('pragma foreign_keys = on'));

package/dialects/sqlite/NodeSqliteDialect.d.ts

@@ -0,0 +1,21 @@
+import { SqliteDialect } from 'kysely';
+/**
+ * Kysely dialect for `node:sqlite` (Node.js 22.5+, Deno 2.2+).
+ *
+ * Bridges `node:sqlite`'s `DatabaseSync` to the `better-sqlite3` interface
+ * that Kysely's `SqliteDialect` expects.
+ *
+ * @example
+ * ```ts
+ * import { SqliteDriver, NodeSqliteDialect } from '@mikro-orm/sql';
+ *
+ * const orm = await MikroORM.init({
+ *   driver: SqliteDriver,
+ *   dbName: ':memory:',
+ *   driverOptions: new NodeSqliteDialect(':memory:'),
+ * });
+ * ```
+ */
+export declare class NodeSqliteDialect extends SqliteDialect {
+    constructor(dbName: string);
+}

package/dialects/sqlite/NodeSqliteDialect.js

@@ -0,0 +1,43 @@
+import { SqliteDialect } from 'kysely';
+/**
+ * Kysely dialect for `node:sqlite` (Node.js 22.5+, Deno 2.2+).
+ *
+ * Bridges `node:sqlite`'s `DatabaseSync` to the `better-sqlite3` interface
+ * that Kysely's `SqliteDialect` expects.
+ *
+ * @example
+ * ```ts
+ * import { SqliteDriver, NodeSqliteDialect } from '@mikro-orm/sql';
+ *
+ * const orm = await MikroORM.init({
+ *   driver: SqliteDriver,
+ *   dbName: ':memory:',
+ *   driverOptions: new NodeSqliteDialect(':memory:'),
+ * });
+ * ```
+ */
+export class NodeSqliteDialect extends SqliteDialect {
+    constructor(dbName) {
+        const { DatabaseSync } = globalThis.process.getBuiltinModule('node:sqlite');
+        super({
+            database: () => {
+                const db = new DatabaseSync(dbName);
+                return {
+                    prepare(sql) {
+                        const stmt = db.prepare(sql);
+                        return {
+                            reader: /^\s*(select|pragma|explain|with)/i.test(sql) || /\breturning\b/i.test(sql),
+                            all: (params) => stmt.all(...params),
+                            run: (params) => stmt.run(...params),
+                            /* v8 ignore next */
+                            get: (params) => stmt.get(...params),
+                        };
+                    },
+                    close() {
+                        db.close();
+                    },
+                };
+            },
+        });
+    }
+}

package/dialects/sqlite/SqliteDriver.d.ts

@@ -0,0 +1,12 @@
+import type { Configuration } from '@mikro-orm/core';
+import { AbstractSqlDriver } from '../../AbstractSqlDriver.js';
+import { BaseSqliteConnection } from './BaseSqliteConnection.js';
+/**
+ * Generic SQLite driver that uses `driverOptions` for the Kysely dialect.
+ * Use this with any SQLite library by passing a Kysely dialect via `driverOptions`.
+ *
+ * For the default better-sqlite3 experience, use `@mikro-orm/sqlite` instead.
+ */
+export declare class SqliteDriver extends AbstractSqlDriver<BaseSqliteConnection> {
+    constructor(config: Configuration);
+}