@mikro-orm/knex 6.1.13-dev.3 → 6.1.13-dev.31

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;
@@ -56,6 +60,7 @@ export const DateType = mod.DateType;
 export const DeadlockException = mod.DeadlockException;
 export const DecimalType = mod.DecimalType;
 export const DefaultLogger = mod.DefaultLogger;
+export const DeferMode = mod.DeferMode;
 export const DoubleType = mod.DoubleType;
 export const DriverException = mod.DriverException;
 export const EagerProps = mod.EagerProps;
@@ -107,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;
@@ -122,6 +128,7 @@ 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 NodeState = mod.NodeState;
 export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
 export const NotFoundError = mod.NotFoundError;
@@ -140,6 +147,7 @@ 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 PrimaryKey = mod.PrimaryKey;
 export const PrimaryKeyProp = mod.PrimaryKeyProp;
 export const Property = mod.Property;
@@ -172,6 +180,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.3",
+  "version": "6.1.13-dev.31",
   "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.3"
+    "@mikro-orm/core": "6.1.13-dev.31"
   }
 }