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

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;
@@ -24,10 +24,11 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
     /**
      * 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 AllEntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends any[] ? NonNullable<TEntityManager['~entities']>[number] : never;
 export {};

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,41 @@
+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);
+}

package/dialects/sqlite/SqliteDriver.js

@@ -0,0 +1,14 @@
+import { AbstractSqlDriver } from '../../AbstractSqlDriver.js';
+import { BaseSqliteConnection } from './BaseSqliteConnection.js';
+import { SqlitePlatform } from './SqlitePlatform.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 class SqliteDriver extends AbstractSqlDriver {
+    constructor(config) {
+        super(config, new SqlitePlatform(), BaseSqliteConnection, ['kysely']);
+    }
+}

package/dialects/sqlite/{BaseSqlitePlatform.d.ts → SqlitePlatform.d.ts}

@@ -3,7 +3,7 @@ import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
 import { SqliteNativeQueryBuilder } from './SqliteNativeQueryBuilder.js';
 import { SqliteSchemaHelper } from './SqliteSchemaHelper.js';
 import { SqliteExceptionConverter } from './SqliteExceptionConverter.js';
-export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
+export declare class SqlitePlatform extends AbstractSqlPlatform {
     protected readonly schemaHelper: SqliteSchemaHelper;
     protected readonly exceptionConverter: SqliteExceptionConverter;
     /** @internal */
@@ -71,6 +71,9 @@ export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
     supportsSchemas(): boolean;
     getDefaultSchemaName(): string | undefined;
     getFullTextWhereClause(): string;
-    quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
+    escape(value: any): string;
+    convertVersionValue(value: Date | number, prop: EntityProperty): number | {
+        $in: (string | number)[];
+    };
     quoteValue(value: any): string;
 }

package/dialects/sqlite/{BaseSqlitePlatform.js → SqlitePlatform.js}

@@ -2,7 +2,7 @@ import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
 import { SqliteNativeQueryBuilder } from './SqliteNativeQueryBuilder.js';
 import { SqliteSchemaHelper } from './SqliteSchemaHelper.js';
 import { SqliteExceptionConverter } from './SqliteExceptionConverter.js';
-export class BaseSqlitePlatform extends AbstractSqlPlatform {
+export class SqlitePlatform extends AbstractSqlPlatform {
     schemaHelper = new SqliteSchemaHelper(this);
     exceptionConverter = new SqliteExceptionConverter();
     /** @internal */
@@ -19,7 +19,7 @@ export class BaseSqlitePlatform extends AbstractSqlPlatform {
         return true;
     }
     getCurrentTimestampSQL(length) {
-        return super.getCurrentTimestampSQL(0);
+        return `(strftime('%s', 'now') * 1000)`;
     }
     getDateTimeTypeDeclarationSQL(column) {
         return 'datetime';
@@ -101,9 +101,32 @@ export class BaseSqlitePlatform extends AbstractSqlPlatform {
     getFullTextWhereClause() {
         return `:column: match :query`;
     }
-    quoteVersionValue(value, prop) {
+    escape(value) {
+        if (value == null) {
+            return 'null';
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'true' : 'false';
+        }
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            return '' + value;
+        }
+        if (value instanceof Date) {
+            return '' + +value;
+        }
+        if (Array.isArray(value)) {
+            return value.map(v => this.escape(v)).join(', ');
+        }
+        if (Buffer.isBuffer(value)) {
+            return `X'${value.toString('hex')}'`;
+        }
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    convertVersionValue(value, prop) {
         if (prop.runtimeType === 'Date') {
-            return this.escape(value).replace(/^'|\.\d{3}'$/g, '');
+            const ts = +value;
+            const str = new Date(ts).toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, '');
+            return { $in: [ts, str] };
         }
         return value;
     }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -39,6 +39,11 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      */
     private extractViewDefinition;
     private getColumns;
+    /**
+     * SQLite strips outer parentheses from expression defaults (`DEFAULT (expr)` → `expr` in pragma).
+     * We need to add them back so they match what we generate in DDL.
+     */
+    private wrapExpressionDefault;
     private getEnumDefinitions;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
     private getIndexes;

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -286,7 +286,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             return {
                 name: col.name,
                 type: col.type,
-                default: col.dflt_value,
+                default: this.wrapExpressionDefault(col.dflt_value),
                 nullable: !col.notnull,
                 primary: !!col.pk,
                 mappedType,
@@ -296,6 +296,25 @@ export class SqliteSchemaHelper extends SchemaHelper {
             };
         });
     }
+    /**
+     * SQLite strips outer parentheses from expression defaults (`DEFAULT (expr)` → `expr` in pragma).
+     * We need to add them back so they match what we generate in DDL.
+     */
+    wrapExpressionDefault(value) {
+        if (value == null) {
+            return null;
+        }
+        // simple values that are returned as-is from pragma (no wrapping needed)
+        if (/^-?\d/.test(value) || /^[xX]'/.test(value) || value[0] === "'" || value[0] === '"' || value[0] === '(') {
+            return value;
+        }
+        const lower = value.toLowerCase();
+        if (['null', 'true', 'false', 'current_timestamp', 'current_date', 'current_time'].includes(lower)) {
+            return value;
+        }
+        // everything else is an expression that had its outer parens stripped
+        return `(${value})`;
+    }
     async getEnumDefinitions(connection, tableName, schemaName) {
         const prefix = this.getSchemaPrefix(schemaName);
         const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;

package/dialects/sqlite/index.d.ts

@@ -1,4 +1,6 @@
 export * from './BaseSqliteConnection.js';
-export * from './BaseSqlitePlatform.js';
+export * from './NodeSqliteDialect.js';
+export * from './SqliteDriver.js';
+export * from './SqlitePlatform.js';
 export * from './SqliteSchemaHelper.js';
 export * from './SqliteNativeQueryBuilder.js';

package/dialects/sqlite/index.js

@@ -1,4 +1,6 @@
 export * from './BaseSqliteConnection.js';
-export * from './BaseSqlitePlatform.js';
+export * from './NodeSqliteDialect.js';
+export * from './SqliteDriver.js';
+export * from './SqlitePlatform.js';
 export * from './SqliteSchemaHelper.js';
 export * from './SqliteNativeQueryBuilder.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.2",
   "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.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-rc.1"
+    "@mikro-orm/core": "7.0.0-rc.2"
   }
 }

package/query/QueryBuilder.d.ts

@@ -1,4 +1,4 @@
-import { type AnyEntity, type AutoPath, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityManager, type EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterObject, type FilterOptions, type FilterValue, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type PopulatePath, QueryFlag, type QueryOrderKeysFlat, type QueryOrderMap, type QueryResult, RawQueryFragment, type Raw, type RequiredEntityData, type Scalar, type Subquery, type Transaction } from '@mikro-orm/core';
+import { type AnyEntity, type AutoPath, type Collection, type ConnectionType, type Dictionary, type EntityData, type EntityDTOFlat, type EntityDTOProp, type EntityKey, type EntityManager, type EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterObject, type FilterOptions, type FilterValue, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type PrimaryProperty, type ObjectQuery, PopulateHint, type PopulateOptions, type PopulatePath, QueryFlag, type QueryOrderKeysFlat, type QueryOrderMap, type QueryResult, RawQueryFragment, type Raw, type RequiredEntityData, type Scalar, type SerializeDTO, type Subquery, type Transaction } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
 import { type Alias, type OnConflictClause, QueryBuilderHelper } from './QueryBuilderHelper.js';
@@ -848,10 +848,36 @@ export interface RunQueryBuilder<Entity extends object, RootAlias extends string
     where(cond: QBFilterQuery<Entity, RootAlias, Context, RawAliases> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;
     execute<Result = QueryResult<Entity>>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
 }
+/**
+ * @internal Optimized DTO type for execute().
+ * Bypasses the double mapped type of EntityDTO<Loaded<T, H, F>> by using DirectDTO
+ * which only iterates selected keys instead of all entity keys.
+ *
+ * - Wildcard, no joins: EntityDTO<T>
+ * - Selected fields, no joins: DirectDTO<T, F> (~132x faster than Pick<EntityDTO<T>, F>)
+ * - Wildcard + single-level join: Omit<EntityDTO<T>> + override populated relations
+ * - Selected fields + single-level join: DirectDTO for root + DirectDTO for joined (~60x faster)
+ * - Wildcard + nested joins: uses SerializeDTO<T, H> (~40x faster than EntityDTO<Loaded<T, H>>)
+ * - Fields + nested joins: falls back to EntityDTO<Loaded<T, H, F>>
+ */
+type DirectDTO<T, F extends keyof T> = {
+    [K in F]: EntityDTOProp<T, NonNullable<T[K]>> | Extract<T[K], null | undefined>;
+};
+type PopulatedDTO<T, K extends keyof T> = NonNullable<T[K]> extends Collection<infer U> ? EntityDTOFlat<U & object>[] : EntityDTOFlat<ExpandProperty<T[K]>>;
+type SubFields<F extends string, Rel extends string> = F extends `${Rel}.${infer Sub}` ? Sub : never;
+type RootFields<F extends string, H extends string> = F extends `${string}.${string}` ? F extends `${H}.${string}` ? never : F : F;
+type JoinDTO<T, K extends keyof T, F extends string> = NonNullable<T[K]> extends Collection<infer U> ? SubFields<F, K & string> extends never ? EntityDTOProp<T, Collection<U>> : DirectDTO<U, (SubFields<F, K & string> | PrimaryProperty<U>) & keyof U>[] : SubFields<F, K & string> extends never ? EntityDTOProp<T, T[K]> : DirectDTO<NonNullable<T[K]>, (SubFields<F, K & string> | PrimaryProperty<NonNullable<T[K]>>) & keyof NonNullable<T[K]>> | Extract<T[K], null | undefined>;
+type ExecuteDTO<T, H extends string, F extends string> = [
+    H
+] extends [never] ? [F] extends ['*'] ? EntityDTOFlat<T> : DirectDTO<T, F & keyof T> : [F] extends ['*'] ? true extends (H extends `${string}.${string}` ? true : false) ? SerializeDTO<T, H> : Omit<EntityDTOFlat<T>, H & keyof EntityDTOFlat<T>> & {
+    [K in H & keyof T as K & keyof EntityDTOFlat<T>]: PopulatedDTO<T, K> | Extract<T[K], null | undefined>;
+} : true extends (H extends `${string}.${string}` ? true : false) ? EntityDTOFlat<Loaded<T, H, F>> : DirectDTO<T, (RootFields<F, H> | PrimaryProperty<T>) & keyof T> & {
+    [K in H & keyof T]: JoinDTO<T, K, F>;
+};
 export interface SelectQueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never, RawAliases extends string = never, Fields extends string = '*'> extends QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields> {
-    execute<Result = Entity[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
-    execute<Result = Entity[]>(method: 'all', mapResults?: boolean): Promise<Result>;
-    execute<Result = Entity>(method: 'get', mapResults?: boolean): Promise<Result>;
+    execute<Result = ExecuteDTO<Entity, Hint, Fields>[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
+    execute<Result = ExecuteDTO<Entity, Hint, Fields>[]>(method: 'all', mapResults?: boolean): Promise<Result>;
+    execute<Result = ExecuteDTO<Entity, Hint, Fields>>(method: 'get', mapResults?: boolean): Promise<Result>;
     execute<Result = QueryResult<Entity>>(method: 'run', mapResults?: boolean): Promise<Result>;
 }
 export interface CountQueryBuilder<Entity extends object> extends QueryBuilder<Entity, any, any> {

package/schema/SqlSchemaGenerator.d.ts

@@ -1,4 +1,5 @@
-import { AbstractSchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type Dictionary, type DropSchemaOptions, type EnsureDatabaseOptions, type EntityMetadata, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
+import { type ClearDatabaseOptions, type CreateSchemaOptions, type Dictionary, type DropSchemaOptions, type EnsureDatabaseOptions, type EntityMetadata, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
+import { AbstractSchemaGenerator } from '@mikro-orm/core/schema';
 import type { SchemaDifference } from '../typings.js';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';

package/schema/SqlSchemaGenerator.js

@@ -1,4 +1,5 @@
-import { AbstractSchemaGenerator, CommitOrderCalculator, Utils, } from '@mikro-orm/core';
+import { CommitOrderCalculator, Utils, } from '@mikro-orm/core';
+import { AbstractSchemaGenerator } from '@mikro-orm/core/schema';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import { SchemaComparator } from './SchemaComparator.js';
 export class SqlSchemaGenerator extends AbstractSchemaGenerator {