@mikro-orm/knex 6.1.13-dev.24 → 6.1.13-dev.26

package/MonkeyPatchable.d.ts

@@ -7,5 +7,6 @@ export declare const MonkeyPatchable: {
     PostgresDialectTableCompiler: any;
     Sqlite3Dialect: any;
     Sqlite3DialectTableCompiler: any;
+    BetterSqlite3Dialect: any;
     TableCompiler: any;
 };

package/MonkeyPatchable.js

@@ -19,6 +19,8 @@ const pg_tablecompiler_1 = __importDefault(require("knex/lib/dialects/postgres/s
 // @ts-ignore
 const sqlite3_1 = __importDefault(require("knex/lib/dialects/sqlite3"));
 // @ts-ignore
+const better_sqlite3_1 = __importDefault(require("knex/lib/dialects/better-sqlite3"));
+// @ts-ignore
 const sqlite_tablecompiler_1 = __importDefault(require("knex/lib/dialects/sqlite3/schema/sqlite-tablecompiler"));
 // @ts-ignore
 const tablecompiler_1 = __importDefault(require("knex/lib/schema/tablecompiler"));
@@ -35,5 +37,6 @@ exports.MonkeyPatchable = {
     PostgresDialectTableCompiler: pg_tablecompiler_1.default,
     Sqlite3Dialect: sqlite3_1.default,
     Sqlite3DialectTableCompiler: sqlite_tablecompiler_1.default,
+    BetterSqlite3Dialect: better_sqlite3_1.default,
     TableCompiler: tablecompiler_1.default,
 };

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite databases. 
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite (including libSQL) databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -175,21 +175,25 @@ First install the module via `yarn` or `npm` and do not forget to install the da
 > Since v4, you should install the driver package, but not the db connector itself, e.g. install `@mikro-orm/sqlite`, but not `sqlite3` as that is already included in the driver package.
 
 ```sh
-yarn add @mikro-orm/core @mikro-orm/mongodb     # for mongo
-yarn add @mikro-orm/core @mikro-orm/mysql       # for mysql/mariadb
-yarn add @mikro-orm/core @mikro-orm/mariadb     # for mysql/mariadb
-yarn add @mikro-orm/core @mikro-orm/postgresql  # for postgresql
-yarn add @mikro-orm/core @mikro-orm/sqlite      # for sqlite
+yarn add @mikro-orm/core @mikro-orm/mongodb       # for mongo
+yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
+yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
+yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
+yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
+yarn add @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
+yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 
 or
 
 ```sh
-npm i -s @mikro-orm/core @mikro-orm/mongodb     # for mongo
-npm i -s @mikro-orm/core @mikro-orm/mysql       # for mysql/mariadb
-npm i -s @mikro-orm/core @mikro-orm/mariadb     # for mysql/mariadb
-npm i -s @mikro-orm/core @mikro-orm/postgresql  # for postgresql
-npm i -s @mikro-orm/core @mikro-orm/sqlite      # for sqlite
+npm i -s @mikro-orm/core @mikro-orm/mongodb       # for mongo
+npm i -s @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
+npm i -s @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
+npm i -s @mikro-orm/core @mikro-orm/postgresql    # for postgresql
+npm i -s @mikro-orm/core @mikro-orm/sqlite        # for sqlite
+npm i -s @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
+npm i -s @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 
 Next, if you want to use decorators for your entity definition, you will need to enable support for [decorators](https://www.typescriptlang.org/docs/handbook/decorators.html) as well as `esModuleInterop` in `tsconfig.json` via:

package/dialects/index.d.ts

@@ -0,0 +1 @@
+export * from './sqlite';

package/dialects/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./sqlite"), exports);

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSqliteConnection = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const AbstractSqlConnection_1 = require("../../AbstractSqlConnection");
+const core_1 = require("@mikro-orm/core");
+class BaseSqliteConnection extends AbstractSqlConnection_1.AbstractSqlConnection {
+    async connect() {
+        this.createKnex();
+        await (0, fs_extra_1.ensureDir)((0, path_1.dirname)(this.config.get('dbName')));
+        await this.client.raw('pragma foreign_keys = on');
+    }
+    getDefaultClientUrl() {
+        return '';
+    }
+    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

@@ -0,0 +1,49 @@
+import { AbstractSqlPlatform } from '../../AbstractSqlPlatform';
+export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
+    usesDefaultKeyword(): boolean;
+    usesReturningStatement(): boolean;
+    getCurrentTimestampSQL(length: number): string;
+    getDateTimeTypeDeclarationSQL(column: {
+        length: number;
+    }): string;
+    getEnumTypeDeclarationSQL(column: {
+        items?: unknown[];
+        fieldNames: string[];
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getTinyIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getSmallIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getIntegerTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getFloatDeclarationSQL(): string;
+    getBooleanTypeDeclarationSQL(): string;
+    getVarcharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    convertsJsonAutomatically(): boolean;
+    allowsComparingTuples(): boolean;
+    /**
+     * This is used to narrow the value of Date properties as they will be stored as timestamps in sqlite.
+     * We use this method to convert Dates to timestamps when computing the changeset, so we have the right
+     * data type in the payload as well as in original entity data. Without that, we would end up with diffs
+     * including all Date properties, as we would be comparing Date object with timestamp.
+     */
+    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;
+    getFullTextWhereClause(): string;
+}

package/dialects/sqlite/BaseSqlitePlatform.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSqlitePlatform = void 0;
+const core_1 = require("@mikro-orm/core");
+const AbstractSqlPlatform_1 = require("../../AbstractSqlPlatform");
+class BaseSqlitePlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
+    usesDefaultKeyword() {
+        return false;
+    }
+    usesReturningStatement() {
+        return true;
+    }
+    getCurrentTimestampSQL(length) {
+        return super.getCurrentTimestampSQL(0);
+    }
+    getDateTimeTypeDeclarationSQL(column) {
+        return 'datetime';
+    }
+    getEnumTypeDeclarationSQL(column) {
+        if (column.items?.every(item => core_1.Utils.isString(item))) {
+            return 'text';
+        }
+        /* istanbul ignore next */
+        return this.getTinyIntTypeDeclarationSQL(column);
+    }
+    getTinyIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL(column);
+    }
+    getSmallIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL(column);
+    }
+    getIntegerTypeDeclarationSQL(column) {
+        return 'integer';
+    }
+    getFloatDeclarationSQL() {
+        return 'real';
+    }
+    getBooleanTypeDeclarationSQL() {
+        return 'integer';
+    }
+    getVarcharTypeDeclarationSQL(column) {
+        return 'text';
+    }
+    convertsJsonAutomatically() {
+        return false;
+    }
+    allowsComparingTuples() {
+        return false;
+    }
+    /**
+     * This is used to narrow the value of Date properties as they will be stored as timestamps in sqlite.
+     * We use this method to convert Dates to timestamps when computing the changeset, so we have the right
+     * data type in the payload as well as in original entity data. Without that, we would end up with diffs
+     * including all Date properties, as we would be comparing Date object with timestamp.
+     */
+    processDateProperty(value) {
+        if (value instanceof Date) {
+            return +value;
+        }
+        return value;
+    }
+    getIndexName(tableName, columns, type) {
+        if (type === 'primary') {
+            return this.getDefaultPrimaryName(tableName, columns);
+        }
+        return super.getIndexName(tableName, columns, type);
+    }
+    getDefaultPrimaryName(tableName, columns) {
+        return 'primary';
+    }
+    supportsDownMigrations() {
+        return false;
+    }
+    getFullTextWhereClause() {
+        return `:column: match :query`;
+    }
+}
+exports.BaseSqlitePlatform = BaseSqlitePlatform;

package/dialects/sqlite/BaseSqliteSchemaHelper.d.ts

@@ -0,0 +1,27 @@
+import type { Connection, Dictionary } from '@mikro-orm/core';
+import type { AbstractSqlConnection } from '../../AbstractSqlConnection';
+import { SchemaHelper } from '../../schema/SchemaHelper';
+import type { CheckDef, Column, IndexDef } from '../../typings';
+export declare abstract class BaseSqliteSchemaHelper extends SchemaHelper {
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    supportsSchemaConstraints(): boolean;
+    getListTablesSQL(): string;
+    getDropDatabaseSQL(name: string): string;
+    getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
+    private parseTableDefinition;
+    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<any[]>;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName: string): Promise<Dictionary<string[]>>;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<CheckDef[]>;
+    getForeignKeysSQL(tableName: string): string;
+    mapForeignKeys(fks: any[], tableName: string): Dictionary;
+    getManagementDbName(): string;
+    getCreateDatabaseSQL(name: string): string;
+    databaseExists(connection: Connection, name: string): Promise<boolean>;
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name: string): boolean;
+}

package/dialects/sqlite/BaseSqliteSchemaHelper.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSqliteSchemaHelper = void 0;
+const SchemaHelper_1 = require("../../schema/SchemaHelper");
+class BaseSqliteSchemaHelper extends SchemaHelper_1.SchemaHelper {
+    disableForeignKeysSQL() {
+        return 'pragma foreign_keys = off;';
+    }
+    enableForeignKeysSQL() {
+        return 'pragma foreign_keys = on;';
+    }
+    supportsSchemaConstraints() {
+        return false;
+    }
+    getListTablesSQL() {
+        return `select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' `
+            + `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`;
+    }
+    getDropDatabaseSQL(name) {
+        if (name === ':memory:') {
+            return '';
+        }
+        /* istanbul ignore next */
+        return `drop database if exists ${this.platform.quoteIdentifier(name)}`;
+    }
+    getDropColumnsSQL(tableName, columns, schemaName) {
+        /* istanbul ignore next */
+        const name = this.platform.quoteIdentifier((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
+        return columns.map(column => {
+            return `alter table ${name} drop column ${this.platform.quoteIdentifier(column.name)}`;
+        }).join(';\n');
+    }
+    parseTableDefinition(sql, cols) {
+        const columns = {};
+        // extract all columns definitions
+        let columnsDef = sql.replaceAll('\n', '').match(new RegExp(`create table [\`"']?.*?[\`"']? \\((.*)\\)`, 'i'))?.[1];
+        /* istanbul ignore else */
+        if (columnsDef) {
+            for (let i = cols.length - 1; i >= 0; i--) {
+                const col = cols[i];
+                const re = ` *, *[\`"']?${col.name}[\`"']? (.*)`;
+                const columnDef = columnsDef.match(new RegExp(re, 'i'));
+                /* istanbul ignore else */
+                if (columnDef) {
+                    columns[col.name] = { name: col.name, definition: columnDef[1] };
+                    columnsDef = columnsDef.substring(0, columnDef.index);
+                }
+            }
+        }
+        return columns;
+    }
+    async getColumns(connection, tableName, schemaName) {
+        const columns = await connection.execute(`pragma table_xinfo('${tableName}')`);
+        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const composite = columns.reduce((count, col) => count + (col.pk ? 1 : 0), 0) > 1;
+        // there can be only one, so naive check like this should be enough
+        const hasAutoincrement = tableDefinition.sql.toLowerCase().includes('autoincrement');
+        const columnDefinitions = this.parseTableDefinition(tableDefinition.sql, columns);
+        return columns.map(col => {
+            const mappedType = connection.getPlatform().getMappedType(col.type);
+            let generated;
+            if (col.hidden > 1) {
+                /* istanbul ignore next */
+                const storage = col.hidden === 2 ? 'virtual' : 'stored';
+                const re = `(generated always)? as \\((.*)\\)( ${storage})?$`;
+                const match = columnDefinitions[col.name].definition.match(re);
+                if (match) {
+                    generated = `${match[2]} ${storage}`;
+                }
+            }
+            return {
+                name: col.name,
+                type: col.type,
+                default: col.dflt_value,
+                nullable: !col.notnull,
+                primary: !!col.pk,
+                mappedType,
+                unsigned: false,
+                autoincrement: !composite && col.pk && this.platform.isNumericColumn(mappedType) && hasAutoincrement,
+                generated,
+            };
+        });
+    }
+    async getEnumDefinitions(connection, checks, tableName, schemaName) {
+        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const checkConstraints = [...tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? []];
+        return checkConstraints.reduce((o, item) => {
+            // check constraints are defined as (note that last closing paren is missing):
+            // `type` text check (`type` in ('local', 'global')
+            const match = item.match(/[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i);
+            /* istanbul ignore else */
+            if (match) {
+                o[match[1]] = match[2].split(',').map((item) => item.trim().match(/^\(?'(.*)'/)[1]);
+            }
+            return o;
+        }, {});
+    }
+    async getPrimaryKeys(connection, indexes, tableName, schemaName) {
+        const sql = `pragma table_info(\`${tableName}\`)`;
+        const cols = await connection.execute(sql);
+        return cols.filter(col => !!col.pk).map(col => col.name);
+    }
+    async getIndexes(connection, tableName, schemaName) {
+        const sql = `pragma table_info(\`${tableName}\`)`;
+        const cols = await connection.execute(sql);
+        const indexes = await connection.execute(`pragma index_list(\`${tableName}\`)`);
+        const ret = [];
+        for (const col of cols.filter(c => c.pk)) {
+            ret.push({
+                columnNames: [col.name],
+                keyName: 'primary',
+                constraint: true,
+                unique: true,
+                primary: true,
+            });
+        }
+        for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
+            const res = await connection.execute(`pragma index_info(\`${index.name}\`)`);
+            ret.push(...res.map(row => ({
+                columnNames: [row.name],
+                keyName: index.name,
+                unique: !!index.unique,
+                constraint: !!index.unique,
+                primary: false,
+            })));
+        }
+        return this.mapIndexes(ret);
+    }
+    async getChecks(connection, tableName, schemaName) {
+        // Not supported at the moment.
+        return [];
+    }
+    getForeignKeysSQL(tableName) {
+        return `pragma foreign_key_list(\`${tableName}\`)`;
+    }
+    mapForeignKeys(fks, tableName) {
+        return fks.reduce((ret, fk) => {
+            ret[fk.from] = {
+                constraintName: this.platform.getIndexName(tableName, [fk.from], 'foreign'),
+                columnName: fk.from,
+                columnNames: [fk.from],
+                localTableName: tableName,
+                referencedTableName: fk.table,
+                referencedColumnName: fk.to,
+                referencedColumnNames: [fk.to],
+                updateRule: fk.on_update.toLowerCase(),
+                deleteRule: fk.on_delete.toLowerCase(),
+            };
+            return ret;
+        }, {});
+    }
+    getManagementDbName() {
+        return '';
+    }
+    getCreateDatabaseSQL(name) {
+        return '';
+    }
+    async databaseExists(connection, name) {
+        const tables = await connection.execute(this.getListTablesSQL());
+        return tables.length > 0;
+    }
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name) {
+        // Ignore indexes with reserved names, e.g. autoindexes
+        return name.startsWith('sqlite_');
+    }
+}
+exports.BaseSqliteSchemaHelper = BaseSqliteSchemaHelper;

package/dialects/sqlite/BetterSqliteKnexDialect.d.ts

@@ -0,0 +1,5 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class BetterSqliteKnexDialect extends MonkeyPatchable.BetterSqlite3Dialect {
+    _driver(): any;
+    tableCompiler(): any;
+}

package/dialects/sqlite/BetterSqliteKnexDialect.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterSqliteKnexDialect = void 0;
+const SqliteTableCompiler_1 = require("./SqliteTableCompiler");
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+class BetterSqliteKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.BetterSqlite3Dialect {
+    _driver() {
+        return require('better-sqlite3');
+    }
+    tableCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new SqliteTableCompiler_1.SqliteTableCompiler(this, ...arguments);
+    }
+}
+exports.BetterSqliteKnexDialect = BetterSqliteKnexDialect;

package/dialects/sqlite/LibSqlKnexDialect.d.ts

@@ -0,0 +1,6 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class LibSqlKnexDialect extends MonkeyPatchable.BetterSqlite3Dialect {
+    get driverName(): string;
+    _driver(): any;
+    tableCompiler(): any;
+}

package/dialects/sqlite/LibSqlKnexDialect.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibSqlKnexDialect = void 0;
+const SqliteTableCompiler_1 = require("./SqliteTableCompiler");
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+class LibSqlKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.BetterSqlite3Dialect {
+    get driverName() {
+        return 'libsql';
+    }
+    _driver() {
+        return require('libsql');
+    }
+    tableCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new SqliteTableCompiler_1.SqliteTableCompiler(this, ...arguments);
+    }
+}
+exports.LibSqlKnexDialect = LibSqlKnexDialect;

package/dialects/sqlite/SqliteKnexDialect.d.ts

@@ -0,0 +1,8 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class SqliteKnexDialect extends MonkeyPatchable.Sqlite3Dialect {
+    tableCompiler(): any;
+    processResponse(obj: any, runner: any): any;
+    _query(connection: any, obj: any): Promise<unknown>;
+    private getCallMethod;
+    private isRunQuery;
+}

package/dialects/sqlite/SqliteKnexDialect.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteKnexDialect = void 0;
+const SqliteTableCompiler_1 = require("./SqliteTableCompiler");
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+class SqliteKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.Sqlite3Dialect {
+    tableCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new SqliteTableCompiler_1.SqliteTableCompiler(this, ...arguments);
+    }
+    processResponse(obj, runner) {
+        if (obj.method === 'raw' && this.isRunQuery(obj.sql)) {
+            return obj.response ?? obj.context;
+        }
+        return super.processResponse(obj, runner);
+    }
+    _query(connection, obj) {
+        const callMethod = this.getCallMethod(obj);
+        return new Promise((resolve, reject) => {
+            /* istanbul ignore if */
+            if (!connection?.[callMethod]) {
+                return reject(new Error(`Error calling ${callMethod} on connection.`));
+            }
+            connection[callMethod](obj.sql, obj.bindings, function (err, response) {
+                if (err) {
+                    return reject(err);
+                }
+                obj.response = response;
+                obj.context = this;
+                return resolve(obj);
+            });
+        });
+    }
+    getCallMethod(obj) {
+        if (obj.method === 'raw') {
+            const query = obj.sql.trim().toLowerCase();
+            if ((query.startsWith('insert into') || query.startsWith('update ')) && query.includes(' returning ')) {
+                return 'all';
+            }
+            if (this.isRunQuery(query)) {
+                return 'run';
+            }
+        }
+        /* istanbul ignore next */
+        switch (obj.method) {
+            case 'insert':
+            case 'update':
+                return obj.returning ? 'all' : 'run';
+            case 'counter':
+            case 'del':
+                return 'run';
+            default:
+                return 'all';
+        }
+    }
+    isRunQuery(query) {
+        query = query.trim().toLowerCase();
+        if ((query.startsWith('insert into') || query.startsWith('update ')) && query.includes(' returning ')) {
+            return false;
+        }
+        return query.startsWith('insert into') ||
+            query.startsWith('update') ||
+            query.startsWith('delete') ||
+            query.startsWith('truncate');
+    }
+}
+exports.SqliteKnexDialect = SqliteKnexDialect;

package/dialects/sqlite/SqliteTableCompiler.d.ts

@@ -0,0 +1,5 @@
+import type { Dictionary } from '@mikro-orm/core';
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class SqliteTableCompiler extends MonkeyPatchable.Sqlite3DialectTableCompiler {
+    foreign(this: any, foreignInfo: Dictionary): void;
+}

package/dialects/sqlite/SqliteTableCompiler.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteTableCompiler = void 0;
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+class SqliteTableCompiler extends MonkeyPatchable_1.MonkeyPatchable.Sqlite3DialectTableCompiler {
+    foreign(foreignInfo) {
+        foreignInfo.column = Array.isArray(foreignInfo.column)
+            ? foreignInfo.column
+            : [foreignInfo.column];
+        foreignInfo.column = foreignInfo.column.map((column) => this.client.customWrapIdentifier(column, (a) => a));
+        foreignInfo.inTable = this.client.customWrapIdentifier(foreignInfo.inTable, (a) => a);
+        foreignInfo.references = Array.isArray(foreignInfo.references)
+            ? foreignInfo.references
+            : [foreignInfo.references];
+        foreignInfo.references = foreignInfo.references.map((column) => this.client.customWrapIdentifier(column, (a) => a));
+        // quoted versions
+        const column = this.formatter.columnize(foreignInfo.column);
+        const inTable = this.formatter.columnize(foreignInfo.inTable);
+        const references = this.formatter.columnize(foreignInfo.references);
+        const keyName = this.formatter.columnize(foreignInfo.keyName);
+        const addColumnQuery = this.sequence.find((query) => query.sql.includes(`add column ${column[0]}`));
+        // no need for temp tables if we just add a column
+        if (addColumnQuery) {
+            /* istanbul ignore next */
+            const onUpdate = foreignInfo.onUpdate ? ` on update ${foreignInfo.onUpdate}` : '';
+            /* istanbul ignore next */
+            const onDelete = foreignInfo.onDelete ? ` on delete ${foreignInfo.onDelete}` : '';
+            addColumnQuery.sql += ` constraint ${keyName} references ${inTable} (${references})${onUpdate}${onDelete}`;
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const compiler = this;
+        if (this.method !== 'create' && this.method !== 'createIfNot') {
+            this.pushQuery({
+                sql: `PRAGMA table_info(${this.tableName()})`,
+                statementsProducer(pragma, connection) {
+                    return compiler.client
+                        .ddl(compiler, pragma, connection)
+                        .foreign(foreignInfo);
+                },
+            });
+        }
+    }
+}
+exports.SqliteTableCompiler = SqliteTableCompiler;

package/dialects/sqlite/index.d.ts

@@ -0,0 +1,7 @@
+export * from './BaseSqliteConnection';
+export * from './BaseSqlitePlatform';
+export * from './BaseSqliteSchemaHelper';
+export * from './SqliteTableCompiler';
+export * from './BetterSqliteKnexDialect';
+export * from './LibSqlKnexDialect';
+export * from './SqliteKnexDialect';

package/dialects/sqlite/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./BaseSqliteConnection"), exports);
+__exportStar(require("./BaseSqlitePlatform"), exports);
+__exportStar(require("./BaseSqliteSchemaHelper"), exports);
+__exportStar(require("./SqliteTableCompiler"), exports);
+__exportStar(require("./BetterSqliteKnexDialect"), exports);
+__exportStar(require("./LibSqlKnexDialect"), exports);
+__exportStar(require("./SqliteKnexDialect"), exports);

package/index.d.ts

@@ -10,6 +10,7 @@ export * from './SqlEntityManager';
 export * from './SqlEntityRepository';
 export * from './query';
 export * from './schema';
+export * from './dialects';
 export * from './typings';
 export { SqlEntityManager as EntityManager } from './SqlEntityManager';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository';

package/index.js

@@ -28,6 +28,7 @@ __exportStar(require("./SqlEntityManager"), exports);
 __exportStar(require("./SqlEntityRepository"), exports);
 __exportStar(require("./query"), exports);
 __exportStar(require("./schema"), exports);
+__exportStar(require("./dialects"), exports);
 __exportStar(require("./typings"), exports);
 var SqlEntityManager_1 = require("./SqlEntityManager");
 Object.defineProperty(exports, "EntityManager", { enumerable: true, get: function () { return SqlEntityManager_1.SqlEntityManager; } });

package/index.mjs

@@ -17,10 +17,14 @@ export const ArrayCollection = mod.ArrayCollection;
 export const ArrayCriteriaNode = mod.ArrayCriteriaNode;
 export const ArrayType = mod.ArrayType;
 export const BaseEntity = mod.BaseEntity;
+export const BaseSqliteConnection = mod.BaseSqliteConnection;
+export const BaseSqlitePlatform = mod.BaseSqlitePlatform;
+export const BaseSqliteSchemaHelper = mod.BaseSqliteSchemaHelper;
 export const BeforeCreate = mod.BeforeCreate;
 export const BeforeDelete = mod.BeforeDelete;
 export const BeforeUpdate = mod.BeforeUpdate;
 export const BeforeUpsert = mod.BeforeUpsert;
+export const BetterSqliteKnexDialect = mod.BetterSqliteKnexDialect;
 export const BigIntType = mod.BigIntType;
 export const BlobType = mod.BlobType;
 export const BooleanType = mod.BooleanType;
@@ -108,6 +112,7 @@ export const JoinType = mod.JoinType;
 export const JsonProperty = mod.JsonProperty;
 export const JsonType = mod.JsonType;
 export const Knex = mod.Knex;
+export const LibSqlKnexDialect = mod.LibSqlKnexDialect;
 export const LoadStrategy = mod.LoadStrategy;
 export const LockMode = mod.LockMode;
 export const LockWaitTimeoutException = mod.LockWaitTimeoutException;
@@ -173,6 +178,8 @@ export const SmallIntType = mod.SmallIntType;
 export const SqlEntityManager = mod.SqlEntityManager;
 export const SqlEntityRepository = mod.SqlEntityRepository;
 export const SqlSchemaGenerator = mod.SqlSchemaGenerator;
+export const SqliteKnexDialect = mod.SqliteKnexDialect;
+export const SqliteTableCompiler = mod.SqliteTableCompiler;
 export const StringType = mod.StringType;
 export const SyntaxErrorException = mod.SyntaxErrorException;
 export const TableExistsException = mod.TableExistsException;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.1.13-dev.24",
+  "version": "6.1.13-dev.26",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^6.1.12"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.1.13-dev.24"
+    "@mikro-orm/core": "6.1.13-dev.26"
   }
 }