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

package/AbstractSqlDriver.d.ts

@@ -19,6 +19,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     private getTableProps;
     /** Creates a FormulaTable object for use in formula callbacks. */
     private createFormulaTable;
+    private validateSqlOptions;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
     private createQueryBuilderFromOptions;
     find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: EntityName<T>, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
@@ -30,6 +31,11 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected streamFromVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any>): AsyncIterableIterator<EntityData<T>>;
     protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
     protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
+    /**
+     * Virtual entities have no PKs, so to-many populate joins can't be deduplicated.
+     * Force balanced strategy to load to-many relations via separate queries.
+     */
+    private forceBalancedStrategy;
     mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T, any, any, any>, map?: Dictionary): EntityData<T> | null;
     /**
      * Maps aliased columns from TPT parent tables back to their original field names.
@@ -134,6 +140,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected buildOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];
     protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, explicit: boolean, parentAlias?: string): QueryOrderMap<T>[];
     protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, parentPath?: string): QueryOrderMap<T>[];
+    private buildToManyOrderBy;
     protected normalizeFields<T extends object>(fields: InternalField<T>[], prefix?: string): string[];
     protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: InternalField<T>[]): void;
     protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>, schema?: string): InternalField<T>[];

package/AbstractSqlDriver.js

@@ -32,6 +32,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const qualifiedName = effectiveSchema ? `${effectiveSchema}.${meta.tableName}` : meta.tableName;
         return { alias, name: meta.tableName, schema: effectiveSchema, qualifiedName, toString: () => alias };
     }
+    validateSqlOptions(options) {
+        if (options.collation != null && typeof options.collation !== 'string') {
+            throw new Error('Collation option for SQL drivers must be a string (collation name). Use a CollationOptions object only with MongoDB.');
+        }
+        if (options.indexHint != null && typeof options.indexHint !== 'string') {
+            throw new Error('indexHint for SQL drivers must be a string (e.g. \'force index(my_index)\'). Use an object only with MongoDB.');
+        }
+    }
     createEntityManager(useContext) {
         const EntityManagerClass = this.config.get('entityManager', SqlEntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
@@ -49,6 +57,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (Utils.isPrimaryKey(where, meta.compositePK)) {
             where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
+        this.validateSqlOptions(options);
         const { first, last, before, after } = options;
         const isCursorPagination = [first, last, before, after].some(v => v != null);
         qb.__populateWhere = options._populateWhere;
@@ -59,6 +68,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             .groupBy(options.groupBy)
             .having(options.having)
             .indexHint(options.indexHint)
+            .collation(options.collation)
             .comment(options.comments)
             .hintComment(options.hintComments);
         if (isCursorPagination) {
@@ -180,7 +190,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         yield* res;
     }
     async wrapVirtualExpressionInSubquery(meta, expression, where, options, type) {
-        const qb = await this.createQueryBuilderFromOptions(meta, where, options);
+        const qb = await this.createQueryBuilderFromOptions(meta, where, this.forceBalancedStrategy(options));
         qb.setFlag(QueryFlag.DISABLE_PAGINATE);
         const isCursorPagination = [options.first, options.last, options.before, options.after].some(v => v != null);
         const native = qb.getNativeQuery(false);
@@ -199,7 +209,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         return res.map(row => this.mapResult(row, meta));
     }
     async *wrapVirtualExpressionInSubqueryStream(meta, expression, where, options, type) {
-        const qb = await this.createQueryBuilderFromOptions(meta, where, options);
+        const qb = await this.createQueryBuilderFromOptions(meta, where, this.forceBalancedStrategy(options));
         qb.unsetFlag(QueryFlag.DISABLE_PAGINATE);
         const native = qb.getNativeQuery(false);
         native.from(raw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`));
@@ -210,6 +220,24 @@ export class AbstractSqlDriver extends DatabaseDriver {
             yield this.mapResult(row, meta);
         }
     }
+    /**
+     * Virtual entities have no PKs, so to-many populate joins can't be deduplicated.
+     * Force balanced strategy to load to-many relations via separate queries.
+     */
+    forceBalancedStrategy(options) {
+        const clearStrategy = (hints) => {
+            return hints.map(hint => ({
+                ...hint,
+                strategy: undefined,
+                children: hint.children ? clearStrategy(hint.children) : undefined,
+            }));
+        };
+        const opts = { ...options, strategy: 'balanced' };
+        if (Array.isArray(opts.populate)) {
+            opts.populate = clearStrategy(opts.populate);
+        }
+        return opts;
+    }
     mapResult(result, meta, populate = [], qb, map = {}) {
         // For TPT inheritance, map aliased parent table columns back to their field names
         if (qb && meta.inheritanceType === 'tpt' && meta.tptParent) {
@@ -474,8 +502,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (meta && !Utils.isEmpty(populate)) {
             this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
         }
+        this.validateSqlOptions(options);
         qb.__populateWhere = options._populateWhere;
         qb.indexHint(options.indexHint)
+            .collation(options.collation)
             .comment(options.comments)
             .hintComment(options.hintComments)
             .groupBy(options.groupBy)
@@ -1486,7 +1516,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             return [raw(`${this.evaluateFormula(prop.formula, columns, table)} as ${aliased}`)];
         }
         return prop.fieldNames.map(fieldName => {
-            return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
+            return raw('?? as ??', [`${tableAlias}.${fieldName}`, `${tableAlias}__${fieldName}`]);
         });
     }
     /** @internal */
@@ -1639,38 +1669,41 @@ export class AbstractSqlDriver extends DatabaseDriver {
         for (const hint of joinedProps) {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
-            const propOrderBy = prop.orderBy;
             let path = `${parentPath}.${propName}`;
             if (prop.kind === ReferenceKind.MANY_TO_MANY && ref) {
                 path += '[pivot]';
             }
-            const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
-            const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
-            if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
-                const alias = ref ? propAlias : join.ownerAlias;
-                orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC });
-            }
-            const effectiveOrderBy = QueryHelper.mergeOrderBy(propOrderBy, prop.targetMeta?.orderBy);
-            for (const item of effectiveOrderBy) {
-                for (const field of Utils.getObjectQueryKeys(item)) {
-                    const order = item[field];
-                    if (RawQueryFragment.isKnownFragmentSymbol(field)) {
-                        const { sql, params } = RawQueryFragment.getKnownFragment(field);
-                        const sql2 = propAlias ? sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : sql;
-                        const key = raw(sql2, params);
-                        orderBy.push({ [key]: order });
-                        continue;
-                    }
-                    orderBy.push({ [`${propAlias}.${field}`]: order });
-                }
+            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+                this.buildToManyOrderBy(qb, prop, path, ref, orderBy);
             }
             if (hint.children) {
-                const buildJoinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, prop.targetMeta, hint.children, options, path);
-                orderBy.push(...buildJoinedPropsOrderBy);
+                orderBy.push(...this.buildJoinedPropsOrderBy(qb, prop.targetMeta, hint.children, options, path));
             }
         }
         return orderBy;
     }
+    buildToManyOrderBy(qb, prop, path, ref, orderBy) {
+        const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
+        const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
+            const alias = ref ? propAlias : join.ownerAlias;
+            orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC });
+        }
+        const effectiveOrderBy = QueryHelper.mergeOrderBy(prop.orderBy, prop.targetMeta?.orderBy);
+        for (const item of effectiveOrderBy) {
+            for (const field of Utils.getObjectQueryKeys(item)) {
+                const order = item[field];
+                if (RawQueryFragment.isKnownFragmentSymbol(field)) {
+                    const { sql, params } = RawQueryFragment.getKnownFragment(field);
+                    const sql2 = propAlias ? sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : sql;
+                    const key = raw(sql2, params);
+                    orderBy.push({ [key]: order });
+                    continue;
+                }
+                orderBy.push({ [`${propAlias}.${field}`]: order });
+            }
+        }
+    }
     normalizeFields(fields, prefix = '') {
         const ret = [];
         for (const field of fields) {

package/AbstractSqlPlatform.d.ts

@@ -33,5 +33,12 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     /**
      * @internal
      */
-    getOrderByExpression(column: string, direction: string): string[];
+    getOrderByExpression(column: string, direction: string, collation?: string): string[];
+    /**
+     * Quotes a collation name for use in COLLATE clauses.
+     * @internal
+     */
+    quoteCollation(collation: string): string;
+    /** @internal */
+    protected validateCollationName(collation: string): void;
 }

package/AbstractSqlPlatform.js

@@ -94,7 +94,24 @@ export class AbstractSqlPlatform extends Platform {
     /**
      * @internal
      */
-    getOrderByExpression(column, direction) {
+    getOrderByExpression(column, direction, collation) {
+        if (collation) {
+            return [`${column} collate ${this.quoteCollation(collation)} ${direction.toLowerCase()}`];
+        }
         return [`${column} ${direction.toLowerCase()}`];
     }
+    /**
+     * Quotes a collation name for use in COLLATE clauses.
+     * @internal
+     */
+    quoteCollation(collation) {
+        this.validateCollationName(collation);
+        return this.quoteIdentifier(collation);
+    }
+    /** @internal */
+    validateCollationName(collation) {
+        if (!/^[\w]+$/.test(collation)) {
+            throw new Error(`Invalid collation name: '${collation}'. Collation names must contain only word characters.`);
+        }
+    }
 }

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/mysql/BaseMySqlPlatform.d.ts

@@ -41,6 +41,6 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     supportsCreatingFullTextIndex(): boolean;
     getFullTextWhereClause(): string;
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
-    getOrderByExpression(column: string, direction: string): string[];
+    getOrderByExpression(column: string, direction: string, collation?: string): string[];
     getDefaultClientUrl(): string;
 }

package/dialects/mysql/BaseMySqlPlatform.js

@@ -105,13 +105,14 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
         const quotedIndexName = this.quoteIdentifier(indexName);
         return `alter table ${quotedTableName} add fulltext index ${quotedIndexName}(${quotedColumnNames.join(',')})`;
     }
-    getOrderByExpression(column, direction) {
+    getOrderByExpression(column, direction, collation) {
         const ret = [];
         const dir = direction.toLowerCase();
+        const col = collation ? `${column} collate ${this.quoteCollation(collation)}` : column;
         if (dir in this.ORDER_BY_NULLS_TRANSLATE) {
-            ret.push(`${column} ${this.ORDER_BY_NULLS_TRANSLATE[dir]}`);
+            ret.push(`${col} ${this.ORDER_BY_NULLS_TRANSLATE[dir]}`);
         }
-        ret.push(`${column} ${dir.replace(/(\s|nulls|first|last)*/gi, '')}`);
+        ret.push(`${col} ${dir.replace(/(\s|nulls|first|last)*/gi, '')}`);
         return ret;
     }
     getDefaultClientUrl() {

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.0",
+  "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.0"
+    "@mikro-orm/core": "7.0.0-rc.2"
   }
 }

package/query/ObjectCriteriaNode.js

@@ -90,7 +90,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
             const operator = Utils.isOperator(field);
             const isRawField = RawQueryFragment.isKnownFragmentSymbol(field);
             // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
-            const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
+            const virtual = childNode.prop?.persist === false && !childNode.prop?.formula && !!options?.type;
             // if key is missing, we are inside group operator and we need to prefix with alias
             const primaryKey = this.key && this.metadata.find(this.entityName)?.primaryKeys.includes(field);
             const isToOne = childNode.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(childNode.prop.kind);