@mikro-orm/better-sqlite 6.1.13-dev.9 → 6.2.1-dev.0

package/BetterSqliteConnection.d.ts

@@ -1,16 +1,4 @@
-import { AbstractSqlConnection, type Knex } from '@mikro-orm/knex';
-export declare class BetterSqliteConnection extends AbstractSqlConnection {
+import { BaseSqliteConnection } from '@mikro-orm/knex';
+export declare class BetterSqliteConnection extends BaseSqliteConnection {
     createKnex(): void;
-    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;
-    /**
-     * monkey patch knex' BetterSqlite Dialect so it returns inserted id when doing raw insert query
-     */
-    private getPatchedDialect;
-    private isRunQuery;
-    private getCallMethod;
 }

package/BetterSqliteConnection.js

@@ -1,166 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BetterSqliteConnection = void 0;
-const fs_extra_1 = require("fs-extra");
-const path_1 = require("path");
 const knex_1 = require("@mikro-orm/knex");
-const core_1 = require("@mikro-orm/core");
-class BetterSqliteConnection extends knex_1.AbstractSqlConnection {
+class BetterSqliteConnection extends knex_1.BaseSqliteConnection {
     createKnex() {
-        this.getPatchedDialect();
-        this.client = this.createKnexClient('better-sqlite3');
+        this.client = this.createKnexClient(knex_1.BetterSqliteKnexDialect);
         this.connected = true;
     }
-    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,
-        };
-    }
-    /**
-     * monkey patch knex' BetterSqlite Dialect so it returns inserted id when doing raw insert query
-     */
-    getPatchedDialect() {
-        const { Sqlite3Dialect, Sqlite3DialectTableCompiler } = knex_1.MonkeyPatchable;
-        if (Sqlite3Dialect.prototype.__patched) {
-            return Sqlite3Dialect;
-        }
-        const processResponse = Sqlite3Dialect.prototype.processResponse;
-        Sqlite3Dialect.prototype.__patched = true;
-        Sqlite3Dialect.prototype.processResponse = (obj, runner) => {
-            if (obj.method === 'raw' && this.isRunQuery(obj.sql)) {
-                return obj.response ?? obj.context;
-            }
-            return processResponse(obj, runner);
-        };
-        Sqlite3Dialect.prototype._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);
-                });
-            });
-        };
-        /* istanbul ignore next */
-        Sqlite3DialectTableCompiler.prototype.foreign = function (foreignInfo) {
-            foreignInfo.column = this.formatter.columnize(foreignInfo.column);
-            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) {
-                const onUpdate = foreignInfo.onUpdate ? ` on update ${foreignInfo.onUpdate}` : '';
-                const deleteRule = foreignInfo.deleteRule ? ` on delete ${foreignInfo.deleteRule}` : '';
-                addColumnQuery.sql += ` constraint ${keyName} references ${inTable} (${references})${onUpdate}${deleteRule}`;
-                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);
-                    },
-                });
-            }
-        };
-        return Sqlite3Dialect;
-    }
-    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');
-    }
-    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';
-        }
-    }
 }
 exports.BetterSqliteConnection = BetterSqliteConnection;

package/BetterSqlitePlatform.d.ts

@@ -1,55 +1,10 @@
 import { type EntityProperty } from '@mikro-orm/core';
-import { AbstractSqlPlatform } from '@mikro-orm/knex';
+import { BaseSqlitePlatform } from '@mikro-orm/knex';
 import { BetterSqliteSchemaHelper } from './BetterSqliteSchemaHelper';
 import { BetterSqliteExceptionConverter } from './BetterSqliteExceptionConverter';
-export declare class BetterSqlitePlatform extends AbstractSqlPlatform {
+export declare class BetterSqlitePlatform extends BaseSqlitePlatform {
     protected readonly schemaHelper: BetterSqliteSchemaHelper;
     protected readonly exceptionConverter: BetterSqliteExceptionConverter;
-    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;
     quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
     quoteValue(value: any): string;
-    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
-    getDefaultPrimaryName(tableName: string, columns: string[]): string;
-    supportsDownMigrations(): boolean;
 }

package/BetterSqlitePlatform.js

@@ -7,64 +7,11 @@ const core_1 = require("@mikro-orm/core");
 const knex_1 = require("@mikro-orm/knex");
 const BetterSqliteSchemaHelper_1 = require("./BetterSqliteSchemaHelper");
 const BetterSqliteExceptionConverter_1 = require("./BetterSqliteExceptionConverter");
-class BetterSqlitePlatform extends knex_1.AbstractSqlPlatform {
+class BetterSqlitePlatform extends knex_1.BaseSqlitePlatform {
     schemaHelper = new BetterSqliteSchemaHelper_1.BetterSqliteSchemaHelper(this);
     exceptionConverter = new BetterSqliteExceptionConverter_1.BetterSqliteExceptionConverter();
-    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';
-        }
-        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;
-    }
     quoteVersionValue(value, prop) {
+        /* istanbul ignore if */
         if (prop.runtimeType === 'Date') {
             return (0, sqlstring_sqlite_1.escape)(value, true, this.timezone).replace(/^'|\.\d{3}'$/g, '');
         }
@@ -80,17 +27,5 @@ class BetterSqlitePlatform extends knex_1.AbstractSqlPlatform {
         }
         return (0, sqlstring_sqlite_1.escape)(value, true, this.timezone);
     }
-    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;
-    }
 }
 exports.BetterSqlitePlatform = BetterSqlitePlatform;

package/BetterSqliteSchemaHelper.d.ts

@@ -1,23 +1,3 @@
-import type { Connection, Dictionary } from '@mikro-orm/core';
-import { SchemaHelper, type AbstractSqlConnection, type IndexDef, type CheckDef } from '@mikro-orm/knex';
-export declare class BetterSqliteSchemaHelper extends SchemaHelper {
-    disableForeignKeysSQL(): string;
-    enableForeignKeysSQL(): string;
-    supportsSchemaConstraints(): boolean;
-    getListTablesSQL(): 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;
+import { BaseSqliteSchemaHelper } from '@mikro-orm/knex';
+export declare class BetterSqliteSchemaHelper extends BaseSqliteSchemaHelper {
 }

package/BetterSqliteSchemaHelper.js

@@ -2,156 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BetterSqliteSchemaHelper = void 0;
 const knex_1 = require("@mikro-orm/knex");
-class BetterSqliteSchemaHelper extends knex_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`;
-    }
-    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) {
-                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_');
-    }
+class BetterSqliteSchemaHelper extends knex_1.BaseSqliteSchemaHelper {
 }
 exports.BetterSqliteSchemaHelper = BetterSqliteSchemaHelper;

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,27 @@ 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/mssql         # for mssql
+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/mssql         # for mssql
+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/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineConfig = exports.MikroORM = void 0;
+/* istanbul ignore file */
 __exportStar(require("@mikro-orm/knex"), exports);
 __exportStar(require("./BetterSqliteConnection"), exports);
 __exportStar(require("./BetterSqliteDriver"), exports);

package/index.mjs

@@ -17,6 +17,9 @@ 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;
@@ -24,6 +27,7 @@ export const BeforeUpsert = mod.BeforeUpsert;
 export const BetterSqliteConnection = mod.BetterSqliteConnection;
 export const BetterSqliteDriver = mod.BetterSqliteDriver;
 export const BetterSqliteExceptionConverter = mod.BetterSqliteExceptionConverter;
+export const BetterSqliteKnexDialect = mod.BetterSqliteKnexDialect;
 export const BetterSqlitePlatform = mod.BetterSqlitePlatform;
 export const BetterSqliteSchemaHelper = mod.BetterSqliteSchemaHelper;
 export const BigIntType = mod.BigIntType;
@@ -113,11 +117,13 @@ 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;
 export const ManyToMany = mod.ManyToMany;
 export const ManyToOne = mod.ManyToOne;
+export const MariaDbKnexDialect = mod.MariaDbKnexDialect;
 export const MediumIntType = mod.MediumIntType;
 export const MemoryCacheAdapter = mod.MemoryCacheAdapter;
 export const MetadataDiscovery = mod.MetadataDiscovery;
@@ -128,6 +134,12 @@ export const MetadataValidator = mod.MetadataValidator;
 export const MikroORM = mod.MikroORM;
 export const MongoNamingStrategy = mod.MongoNamingStrategy;
 export const MonkeyPatchable = mod.MonkeyPatchable;
+export const MsSqlKnexDialect = mod.MsSqlKnexDialect;
+export const MySqlConnection = mod.MySqlConnection;
+export const MySqlExceptionConverter = mod.MySqlExceptionConverter;
+export const MySqlKnexDialect = mod.MySqlKnexDialect;
+export const MySqlPlatform = mod.MySqlPlatform;
+export const MySqlSchemaHelper = mod.MySqlSchemaHelper;
 export const NodeState = mod.NodeState;
 export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
 export const NotFoundError = mod.NotFoundError;
@@ -146,6 +158,8 @@ export const OptionalProps = mod.OptionalProps;
 export const PlainObject = mod.PlainObject;
 export const Platform = mod.Platform;
 export const PopulateHint = mod.PopulateHint;
+export const PopulatePath = mod.PopulatePath;
+export const PostgreSqlKnexDialect = mod.PostgreSqlKnexDialect;
 export const PrimaryKey = mod.PrimaryKey;
 export const PrimaryKeyProp = mod.PrimaryKeyProp;
 export const Property = mod.Property;
@@ -178,6 +192,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/better-sqlite",
-  "version": "6.1.13-dev.9",
+  "version": "6.2.1-dev.0",
   "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",
@@ -58,15 +58,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/knex": "6.1.13-dev.9",
-    "better-sqlite3": "9.4.3",
+    "@mikro-orm/knex": "6.2.1-dev.0",
+    "better-sqlite3": "9.4.5",
     "fs-extra": "11.2.0",
     "sqlstring-sqlite": "0.1.1"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.1.12"
+    "@mikro-orm/core": "^6.2.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.1.13-dev.9"
+    "@mikro-orm/core": "6.2.1-dev.0"
   }
 }