@mikro-orm/knex 6.4.6-dev.8 → 7.0.0-dev.0

package/dialects/mysql/MySqlExceptionConverter.js

@@ -27,6 +27,7 @@ class MySqlExceptionConverter extends core_1.ExceptionConverter {
             case 1701:
                 return new core_1.ForeignKeyConstraintViolationException(exception);
             case 3819:
+            case 4025:
                 return new core_1.CheckConstraintViolationException(exception);
             case 1062:
             case 1557:

package/dialects/mysql/MySqlNativeQueryBuilder.d.ts

@@ -0,0 +1,7 @@
+import { NativeQueryBuilder } from '../../query/NativeQueryBuilder';
+/** @internal */
+export declare class MySqlNativeQueryBuilder extends NativeQueryBuilder {
+    protected compileInsert(): void;
+    protected addLockClause(): void;
+    protected addOnConflictClause(): void;
+}

package/dialects/mysql/MySqlNativeQueryBuilder.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlNativeQueryBuilder = void 0;
+const core_1 = require("@mikro-orm/core");
+const NativeQueryBuilder_1 = require("../../query/NativeQueryBuilder");
+/** @internal */
+class MySqlNativeQueryBuilder extends NativeQueryBuilder_1.NativeQueryBuilder {
+    compileInsert() {
+        if (!this.options.data) {
+            throw new Error('No data provided');
+        }
+        this.parts.push('insert');
+        if (this.options.onConflict?.ignore) {
+            this.parts.push('ignore');
+        }
+        this.addHintComment();
+        this.parts.push(`into ${this.getTableName()}`);
+        if (Object.keys(this.options.data).length === 0) {
+            this.parts.push('default values');
+            return;
+        }
+        const parts = this.processInsertData();
+        this.parts.push(parts.join(', '));
+    }
+    addLockClause() {
+        if (!this.options.lockMode) {
+            return;
+        }
+        const map = {
+            [core_1.LockMode.PESSIMISTIC_READ]: 'lock in share mode',
+            [core_1.LockMode.PESSIMISTIC_WRITE]: 'for update',
+            [core_1.LockMode.PESSIMISTIC_PARTIAL_WRITE]: 'for update skip locked',
+            [core_1.LockMode.PESSIMISTIC_WRITE_OR_FAIL]: 'for update nowait',
+            [core_1.LockMode.PESSIMISTIC_PARTIAL_READ]: 'lock in share mode skip locked',
+            [core_1.LockMode.PESSIMISTIC_READ_OR_FAIL]: 'lock in share mode nowait',
+        };
+        if (this.options.lockMode !== core_1.LockMode.OPTIMISTIC) {
+            this.parts.push(map[this.options.lockMode]);
+        }
+    }
+    addOnConflictClause() {
+        const clause = this.options.onConflict;
+        if (!clause || clause.ignore) {
+            return;
+        }
+        if (clause.merge) {
+            this.parts.push('on duplicate key update');
+            if (core_1.Utils.isObject(clause.merge)) {
+                const fields = Object.keys(clause.merge).map(field => {
+                    this.params.push(clause.merge[field]);
+                    return `${this.quote(field)} = ?`;
+                });
+                this.parts.push(fields.join(', '));
+            }
+            else if (clause.merge.length === 0) {
+                const dataAsArray = core_1.Utils.asArray(this.options.data);
+                const keys = Object.keys(dataAsArray[0]);
+                this.parts.push(keys.map(key => `${this.quote(key)} = values(${this.quote(key)})`).join(', '));
+            }
+            else {
+                const fields = clause.merge.map(key => `${this.quote(key)} = values(${this.quote(key)})`);
+                this.parts.push(fields.join(', '));
+            }
+            if (clause.where) {
+                this.parts.push(`where ${clause.where.sql}`);
+                this.params.push(...clause.where.params);
+            }
+            return;
+        }
+        this.parts.push('on conflict');
+        if (clause.fields instanceof core_1.RawQueryFragment) {
+            this.parts.push(clause.fields.sql);
+            this.params.push(...clause.fields.params);
+        }
+        else if (clause.fields.length > 0) {
+            const fields = clause.fields.map(field => this.quote(field));
+            this.parts.push(`(${fields.join(', ')})`);
+        }
+    }
+}
+exports.MySqlNativeQueryBuilder = MySqlNativeQueryBuilder;

package/dialects/mysql/MySqlPlatform.d.ts

@@ -3,6 +3,7 @@ import { MySqlSchemaHelper } from './MySqlSchemaHelper';
 import { MySqlExceptionConverter } from './MySqlExceptionConverter';
 import { AbstractSqlPlatform } from '../../AbstractSqlPlatform';
 import type { IndexDef } from '../../typings';
+import { MySqlNativeQueryBuilder } from './MySqlNativeQueryBuilder';
 export declare class MySqlPlatform extends AbstractSqlPlatform {
     protected readonly schemaHelper: MySqlSchemaHelper;
     protected readonly exceptionConverter: MySqlExceptionConverter;
@@ -12,11 +13,13 @@ export declare class MySqlPlatform extends AbstractSqlPlatform {
         readonly "desc nulls first": "is not null";
         readonly "desc nulls last": "is null";
     };
+    /** @internal */
+    createNativeQueryBuilder(): MySqlNativeQueryBuilder;
     getDefaultCharset(): string;
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
     getJsonIndexDefinition(index: IndexDef): string[];
     getBooleanTypeDeclarationSQL(): string;
-    normalizeColumnType(type: string, options?: {
+    normalizeColumnType(type: string, options: {
         length?: number;
         precision?: number;
         scale?: number;
@@ -34,4 +37,5 @@ export declare class MySqlPlatform extends AbstractSqlPlatform {
     getFullTextWhereClause(): string;
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
     getOrderByExpression(column: string, direction: string): string[];
+    getDefaultClientUrl(): string;
 }

package/dialects/mysql/MySqlPlatform.js

@@ -5,6 +5,7 @@ const core_1 = require("@mikro-orm/core");
 const MySqlSchemaHelper_1 = require("./MySqlSchemaHelper");
 const MySqlExceptionConverter_1 = require("./MySqlExceptionConverter");
 const AbstractSqlPlatform_1 = require("../../AbstractSqlPlatform");
+const MySqlNativeQueryBuilder_1 = require("./MySqlNativeQueryBuilder");
 class MySqlPlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
     schemaHelper = new MySqlSchemaHelper_1.MySqlSchemaHelper(this);
     exceptionConverter = new MySqlExceptionConverter_1.MySqlExceptionConverter();
@@ -14,6 +15,10 @@ class MySqlPlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
         [core_1.QueryOrder.desc_nulls_first]: 'is not null',
         [core_1.QueryOrder.desc_nulls_last]: 'is null',
     };
+    /** @internal */
+    createNativeQueryBuilder() {
+        return new MySqlNativeQueryBuilder_1.MySqlNativeQueryBuilder(this);
+    }
     getDefaultCharset() {
         return 'utf8mb4';
     }
@@ -36,7 +41,7 @@ class MySqlPlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
     getBooleanTypeDeclarationSQL() {
         return 'tinyint(1)';
     }
-    normalizeColumnType(type, options = {}) {
+    normalizeColumnType(type, options) {
         const simpleType = this.extractSimpleType(type);
         if (['decimal', 'numeric'].includes(simpleType)) {
             return this.getDecimalTypeDeclarationSQL(options);
@@ -94,5 +99,8 @@ class MySqlPlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
         ret.push(`${column} ${dir.replace(/(\s|nulls|first|last)*/gi, '')}`);
         return ret;
     }
+    getDefaultClientUrl() {
+        return 'mysql://root@127.0.0.1:3306';
+    }
 }
 exports.MySqlPlatform = MySqlPlatform;

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -1,6 +1,5 @@
-import type { Knex } from 'knex';
-import type { CheckDef, Column, IndexDef, TableDifference, Table, ForeignKey, MySqlTableBuilder } from '../../typings';
 import { type Dictionary, type Type } from '@mikro-orm/core';
+import type { CheckDef, Column, IndexDef, TableDifference, Table, ForeignKey } from '../../typings';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection';
 import { SchemaHelper } from '../../schema/SchemaHelper';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema';
@@ -15,28 +14,23 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
-    finalizeTable(table: Knex.CreateTableBuilder, charset: string, collate?: string): void;
+    finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     getListTablesSQL(): string;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
     getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
+    getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
     getAllColumns(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Column[]>>;
     getAllChecks(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<CheckDef[]>>;
     getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<ForeignKey>>>;
-    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
-    createTableColumn(table: MySqlTableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder | undefined;
-    configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
+    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;
-    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+    alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
     private getColumnDeclarationSQL;
-    getForeignKeysSQL(tableName: string, schemaName?: string): string;
     getAllEnumDefinitions(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<string[]>>>;
     private supportsCheckConstraints;
     protected getChecksSQL(tables: Table[]): string;
-    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName: string, columns?: Column[]): Promise<CheckDef[]>;
-    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
-    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
-    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
     normalizeDefaultValue(defaultValue: string, length: number): string | number;
     protected wrap(val: string | null | undefined, type: Type<unknown>): string | null | undefined;
 }

package/dialects/mysql/MySqlSchemaHelper.js

@@ -23,11 +23,15 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
         return 'set foreign_key_checks = 1;';
     }
     finalizeTable(table, charset, collate) {
-        table.engine('InnoDB');
-        table.charset(charset);
+        let sql = ` default character set ${charset}`;
         if (collate) {
-            table.collate(collate);
+            sql += ` collate ${collate}`;
         }
+        sql += ' engine = InnoDB';
+        if (table.comment) {
+            sql += ` comment = ${this.platform.quoteValue(table.comment)}`;
+        }
+        return sql;
     }
     getListTablesSQL() {
         return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
@@ -76,6 +80,25 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
         }
         return ret;
     }
+    getCreateIndexSQL(tableName, index, partialExpression = false) {
+        /* istanbul ignore next */
+        if (index.expression && !partialExpression) {
+            return index.expression;
+        }
+        tableName = this.quote(tableName);
+        const keyName = this.quote(index.keyName);
+        const sql = `alter table ${tableName} add ${index.unique ? 'unique' : 'index'} ${keyName} `;
+        if (index.expression && partialExpression) {
+            return `${sql}(${index.expression})`;
+        }
+        // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+        if (index.columnNames.some(column => column.includes('.'))) {
+            const columns = this.platform.getJsonIndexDefinition(index);
+            const sql = `alter table ${tableName} add ${index.unique ? 'unique ' : ''}index ${keyName} `;
+            return `${sql}(${columns.join(', ')})`;
+        }
+        return `${sql}(${index.columnNames.map(c => this.quote(c)).join(', ')})`;
+    }
     async getAllColumns(connection, tables) {
         const sql = `select table_name as table_name,
       nullif(table_schema, schema()) as schema_name,
@@ -171,81 +194,45 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
         // Dropping primary keys requires to unset autoincrement attribute on the particular column first.
         const pk = Object.values(tableDiff.removedIndexes).find(idx => idx.primary);
         if (!pk || safe) {
-            return '';
+            return [];
         }
         return pk.columnNames
             .filter(col => tableDiff.fromTable.hasColumn(col))
             .map(col => tableDiff.fromTable.getColumn(col))
             .filter(col => col.autoincrement)
-            .map(col => `alter table \`${tableDiff.name}\` modify \`${col.name}\` ${this.getColumnDeclarationSQL({ ...col, autoincrement: false })}`)
-            .join(';\n');
-    }
-    createTableColumn(table, column, fromTable, changedProperties, alter) {
-        const compositePK = fromTable.getPrimaryKey()?.composite;
-        if (column.autoincrement && !column.generated && !compositePK && column.primary) {
-            const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
-            if (column.mappedType instanceof core_1.BigIntType) {
-                return table.bigIncrements(column.name, { primaryKey, unsigned: column.unsigned, type: column.type });
-            }
-            return table.increments(column.name, { primaryKey, unsigned: column.unsigned, type: column.type });
-        }
-        if (column.mappedType instanceof core_1.EnumType && column.enumItems?.every(item => core_1.Utils.isString(item))) {
-            return table.enum(column.name, column.enumItems);
-        }
-        let columnType = column.type;
-        if (column.generated) {
-            columnType += ` generated always as ${column.generated}`;
-        }
-        return table.specificType(column.name, columnType);
-    }
-    configureColumnDefault(column, col, knex, changedProperties) {
-        if (changedProperties || column.default !== undefined) {
-            if (column.default == null) {
-                col.defaultTo(null);
-            }
-            else {
-                col.defaultTo(knex.raw(column.default + (column.extra ? ' ' + column.extra : '')));
-            }
-        }
-        return col;
+            .map(col => `alter table \`${tableDiff.name}\` modify \`${col.name}\` ${this.getColumnDeclarationSQL({ ...col, autoincrement: false })}`);
     }
     getRenameColumnSQL(tableName, oldColumnName, to) {
-        tableName = this.platform.quoteIdentifier(tableName);
-        oldColumnName = this.platform.quoteIdentifier(oldColumnName);
-        const columnName = this.platform.quoteIdentifier(to.name);
+        tableName = this.quote(tableName);
+        oldColumnName = this.quote(oldColumnName);
+        const columnName = this.quote(to.name);
         return `alter table ${tableName} change ${oldColumnName} ${columnName} ${this.getColumnDeclarationSQL(to)}`;
     }
     getRenameIndexSQL(tableName, index, oldIndexName) {
-        tableName = this.platform.quoteIdentifier(tableName);
-        oldIndexName = this.platform.quoteIdentifier(oldIndexName);
-        const keyName = this.platform.quoteIdentifier(index.keyName);
-        return `alter table ${tableName} rename index ${oldIndexName} to ${keyName}`;
+        tableName = this.quote(tableName);
+        oldIndexName = this.quote(oldIndexName);
+        const keyName = this.quote(index.keyName);
+        return [`alter table ${tableName} rename index ${oldIndexName} to ${keyName}`];
     }
     getChangeColumnCommentSQL(tableName, to, schemaName) {
-        tableName = this.platform.quoteIdentifier(tableName);
-        const columnName = this.platform.quoteIdentifier(to.name);
+        tableName = this.quote(tableName);
+        const columnName = this.quote(to.name);
         return `alter table ${tableName} modify ${columnName} ${this.getColumnDeclarationSQL(to)}`;
     }
-    getColumnDeclarationSQL(col, addPrimary = false) {
+    alterTableColumn(column, table, changedProperties) {
+        const col = this.createTableColumn(column, table, changedProperties);
+        return [`alter table ${table.getQuotedName()} modify ${col}`];
+    }
+    getColumnDeclarationSQL(col) {
         let ret = col.type;
         ret += col.unsigned ? ' unsigned' : '';
         ret += col.autoincrement ? ' auto_increment' : '';
         ret += ' ';
         ret += col.nullable ? 'null' : 'not null';
         ret += col.default ? ' default ' + col.default : '';
-        if (addPrimary && col.primary) {
-            ret += ' primary key';
-        }
         ret += col.comment ? ` comment ${this.platform.quoteValue(col.comment)}` : '';
         return ret;
     }
-    /* istanbul ignore next kept for BC */
-    getForeignKeysSQL(tableName, schemaName) {
-        return `select distinct k.constraint_name as constraint_name, k.column_name as column_name, k.referenced_table_name as referenced_table_name, k.referenced_column_name as referenced_column_name, c.update_rule as update_rule, c.delete_rule as delete_rule `
-            + `from information_schema.key_column_usage k `
-            + `inner join information_schema.referential_constraints c on c.constraint_name = k.constraint_name and c.table_name = '${tableName}' `
-            + `where k.table_name = '${tableName}' and k.table_schema = database() and c.constraint_schema = database() and k.referenced_column_name is not null`;
-    }
     async getAllEnumDefinitions(connection, tables) {
         const sql = `select column_name as column_name, column_type as column_type, table_name as table_name
       from information_schema.columns
@@ -275,26 +262,6 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
       where tc.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))}) and tc.constraint_schema = database()
       order by tc.constraint_name`;
     }
-    /* istanbul ignore next */
-    async getChecks(connection, tableName, schemaName, columns) {
-        const res = await this.getAllChecks(connection, [{ table_name: tableName, schema_name: schemaName }]);
-        return res[tableName];
-    }
-    /* istanbul ignore next */
-    async getEnumDefinitions(connection, checks, tableName, schemaName) {
-        const res = await this.getAllEnumDefinitions(connection, [{ table_name: tableName, schema_name: schemaName }]);
-        return res[tableName];
-    }
-    /* istanbul ignore next */
-    async getColumns(connection, tableName, schemaName) {
-        const res = await this.getAllColumns(connection, [{ table_name: tableName, schema_name: schemaName }]);
-        return res[tableName];
-    }
-    /* istanbul ignore next */
-    async getIndexes(connection, tableName, schemaName) {
-        const res = await this.getAllIndexes(connection, [{ table_name: tableName, schema_name: schemaName }]);
-        return res[tableName];
-    }
     normalizeDefaultValue(defaultValue, length) {
         return super.normalizeDefaultValue(defaultValue, length, MySqlSchemaHelper.DEFAULT_VALUES);
     }

package/dialects/mysql/index.d.ts

@@ -1,6 +1,4 @@
-export * from './MariaDbKnexDialect';
-export * from './MySqlKnexDialect';
-export * from './MySqlConnection';
 export * from './MySqlExceptionConverter';
 export * from './MySqlSchemaHelper';
 export * from './MySqlPlatform';
+export * from './MySqlNativeQueryBuilder';

package/dialects/mysql/index.js

@@ -14,9 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./MariaDbKnexDialect"), exports);
-__exportStar(require("./MySqlKnexDialect"), exports);
-__exportStar(require("./MySqlConnection"), exports);
 __exportStar(require("./MySqlExceptionConverter"), exports);
 __exportStar(require("./MySqlSchemaHelper"), exports);
 __exportStar(require("./MySqlPlatform"), exports);
+__exportStar(require("./MySqlNativeQueryBuilder"), exports);

package/dialects/postgresql/PostgreSqlNativeQueryBuilder.d.ts

@@ -0,0 +1,5 @@
+import { NativeQueryBuilder } from '../../query/NativeQueryBuilder';
+/** @internal */
+export declare class PostgreSqlNativeQueryBuilder extends NativeQueryBuilder {
+    protected compileTruncate(): void;
+}

package/dialects/postgresql/PostgreSqlNativeQueryBuilder.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSqlNativeQueryBuilder = void 0;
+const NativeQueryBuilder_1 = require("../../query/NativeQueryBuilder");
+/** @internal */
+class PostgreSqlNativeQueryBuilder extends NativeQueryBuilder_1.NativeQueryBuilder {
+    compileTruncate() {
+        super.compileTruncate();
+        this.parts.push('restart identity cascade');
+    }
+}
+exports.PostgreSqlNativeQueryBuilder = PostgreSqlNativeQueryBuilder;

package/dialects/postgresql/index.d.ts

@@ -1 +1 @@
-export * from './PostgreSqlKnexDialect';
+export * from './PostgreSqlNativeQueryBuilder';

package/dialects/postgresql/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./PostgreSqlKnexDialect"), exports);
+__exportStar(require("./PostgreSqlNativeQueryBuilder"), exports);

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -1,10 +1,5 @@
-import type { Knex } from 'knex';
 import { AbstractSqlConnection } from '../../AbstractSqlConnection';
 export declare abstract class BaseSqliteConnection extends AbstractSqlConnection {
     connect(): Promise<void>;
-    getDefaultClientUrl(): string;
     getClientUrl(): string;
-    loadFile(path: string): Promise<void>;
-    protected getKnexOptions(type: string): Knex.Config;
-    protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
 }

package/dialects/sqlite/BaseSqliteConnection.js

@@ -1,56 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseSqliteConnection = void 0;
-const fs_extra_1 = require("fs-extra");
 const node_path_1 = require("node:path");
+const fs_extra_1 = require("fs-extra");
+const kysely_1 = require("kysely");
 const AbstractSqlConnection_1 = require("../../AbstractSqlConnection");
-const core_1 = require("@mikro-orm/core");
 class BaseSqliteConnection extends AbstractSqlConnection_1.AbstractSqlConnection {
     async connect() {
-        this.createKnex();
+        await super.connect();
         await (0, fs_extra_1.ensureDir)((0, node_path_1.dirname)(this.config.get('dbName')));
-        await this.client.raw('pragma foreign_keys = on');
-    }
-    getDefaultClientUrl() {
-        return '';
+        await this.client.executeQuery(kysely_1.CompiledQuery.raw('pragma foreign_keys = on'));
     }
     getClientUrl() {
         return '';
     }
-    async loadFile(path) {
-        const conn = await this.client.client.acquireConnection();
-        await conn.exec((await (0, fs_extra_1.readFile)(path)).toString());
-        await this.client.client.releaseConnection(conn);
-    }
-    getKnexOptions(type) {
-        return core_1.Utils.mergeConfig({
-            client: type,
-            connection: {
-                filename: this.config.get('dbName'),
-            },
-            pool: this.config.get('pool'),
-            useNullAsDefault: true,
-        }, this.config.get('driverOptions'));
-    }
-    transformRawResult(res, method) {
-        if (method === 'get') {
-            return res[0];
-        }
-        if (method === 'all') {
-            return res;
-        }
-        if (Array.isArray(res)) {
-            return {
-                insertId: res[res.length - 1]?.id ?? 0,
-                affectedRows: res.length,
-                row: res[0],
-                rows: res,
-            };
-        }
-        return {
-            insertId: res.lastInsertRowid,
-            affectedRows: res.changes,
-        };
-    }
 }
 exports.BaseSqliteConnection = BaseSqliteConnection;

package/dialects/sqlite/BaseSqlitePlatform.d.ts

@@ -1,12 +1,24 @@
-import { type EntityProperty } from '@mikro-orm/core';
+import { type EntityProperty, type IsolationLevel } from '@mikro-orm/core';
 import { AbstractSqlPlatform } from '../../AbstractSqlPlatform';
+import { SqliteNativeQueryBuilder } from './SqliteNativeQueryBuilder';
+import { SqliteSchemaHelper } from './SqliteSchemaHelper';
+import { SqliteExceptionConverter } from './SqliteExceptionConverter';
 export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
+    protected readonly schemaHelper: SqliteSchemaHelper;
+    protected readonly exceptionConverter: SqliteExceptionConverter;
+    /** @internal */
+    createNativeQueryBuilder(): SqliteNativeQueryBuilder;
     usesDefaultKeyword(): boolean;
     usesReturningStatement(): boolean;
+    usesEnumCheckConstraints(): boolean;
     getCurrentTimestampSQL(length: number): string;
     getDateTimeTypeDeclarationSQL(column: {
         length: number;
     }): string;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
     getEnumTypeDeclarationSQL(column: {
         items?: unknown[];
         fieldNames: string[];
@@ -37,7 +49,7 @@ export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
     getVarcharTypeDeclarationSQL(column: {
         length?: number;
     }): string;
-    normalizeColumnType(type: string, options?: {
+    normalizeColumnType(type: string, options: {
         length?: number;
         precision?: number;
         scale?: number;
@@ -51,8 +63,8 @@ export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
      */
     processDateProperty(value: unknown): string | number | Date;
     getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
-    getDefaultPrimaryName(tableName: string, columns: string[]): string;
     supportsDownMigrations(): boolean;
+    supportsDeferredUniqueConstraints(): boolean;
     getFullTextWhereClause(): string;
     quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
     quoteValue(value: any): string;

package/dialects/sqlite/BaseSqlitePlatform.js

@@ -3,19 +3,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseSqlitePlatform = void 0;
 const core_1 = require("@mikro-orm/core");
 const AbstractSqlPlatform_1 = require("../../AbstractSqlPlatform");
+const SqliteNativeQueryBuilder_1 = require("./SqliteNativeQueryBuilder");
+const SqliteSchemaHelper_1 = require("./SqliteSchemaHelper");
+const SqliteExceptionConverter_1 = require("./SqliteExceptionConverter");
 class BaseSqlitePlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
+    schemaHelper = new SqliteSchemaHelper_1.SqliteSchemaHelper(this);
+    exceptionConverter = new SqliteExceptionConverter_1.SqliteExceptionConverter();
+    /** @internal */
+    createNativeQueryBuilder() {
+        return new SqliteNativeQueryBuilder_1.SqliteNativeQueryBuilder(this);
+    }
     usesDefaultKeyword() {
         return false;
     }
     usesReturningStatement() {
         return true;
     }
+    usesEnumCheckConstraints() {
+        return true;
+    }
     getCurrentTimestampSQL(length) {
         return super.getCurrentTimestampSQL(0);
     }
     getDateTimeTypeDeclarationSQL(column) {
         return 'datetime';
     }
+    getBeginTransactionSQL(options) {
+        return ['begin'];
+    }
     getEnumTypeDeclarationSQL(column) {
         if (column.items?.every(item => core_1.Utils.isString(item))) {
             return 'text';
@@ -44,7 +59,7 @@ class BaseSqlitePlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
     getVarcharTypeDeclarationSQL(column) {
         return 'text';
     }
-    normalizeColumnType(type, options = {}) {
+    normalizeColumnType(type, options) {
         const simpleType = this.extractSimpleType(type);
         if (['varchar', 'text'].includes(simpleType)) {
             return this.getVarcharTypeDeclarationSQL(options);
@@ -72,12 +87,13 @@ class BaseSqlitePlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
         }
         return super.getIndexName(tableName, columns, type);
     }
-    getDefaultPrimaryName(tableName, columns) {
-        return 'primary';
-    }
+    // TODO enable once tests are green
     supportsDownMigrations() {
         return false;
     }
+    supportsDeferredUniqueConstraints() {
+        return false;
+    }
     getFullTextWhereClause() {
         return `:column: match :query`;
     }

package/dialects/sqlite/SqliteExceptionConverter.d.ts

@@ -0,0 +1,9 @@
+import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
+export declare class SqliteExceptionConverter extends ExceptionConverter {
+    /**
+     * @inheritDoc
+     * @link http://www.sqlite.org/c3ref/c_abort.html
+     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractSQLiteDriver.php
+     */
+    convertException(exception: Error & Dictionary): DriverException;
+}