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

package/dialects/sqlite/SqliteExceptionConverter.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteExceptionConverter = void 0;
+const core_1 = require("@mikro-orm/core");
+class SqliteExceptionConverter extends core_1.ExceptionConverter {
+    /* istanbul ignore next */
+    /**
+     * @inheritDoc
+     * @link http://www.sqlite.org/c3ref/c_abort.html
+     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractSQLiteDriver.php
+     */
+    convertException(exception) {
+        if (exception.message.includes('database is locked')) {
+            return new core_1.LockWaitTimeoutException(exception);
+        }
+        if (exception.message.includes('must be unique') ||
+            exception.message.includes('is not unique') ||
+            exception.message.includes('are not unique') ||
+            exception.message.includes('UNIQUE constraint failed')) {
+            return new core_1.UniqueConstraintViolationException(exception);
+        }
+        if (exception.message.includes('may not be NULL') || exception.message.includes('NOT NULL constraint failed')) {
+            return new core_1.NotNullConstraintViolationException(exception);
+        }
+        if (exception.message.includes('CHECK constraint failed')) {
+            return new core_1.CheckConstraintViolationException(exception);
+        }
+        if (exception.message.includes('no such table:')) {
+            return new core_1.TableNotFoundException(exception);
+        }
+        if (exception.message.includes('already exists')) {
+            return new core_1.TableExistsException(exception);
+        }
+        if (exception.message.includes('no such column:')) {
+            return new core_1.InvalidFieldNameException(exception);
+        }
+        if (exception.message.includes('ambiguous column name')) {
+            return new core_1.NonUniqueFieldNameException(exception);
+        }
+        if (exception.message.includes('syntax error')) {
+            return new core_1.SyntaxErrorException(exception);
+        }
+        if (exception.message.includes('attempt to write a readonly database')) {
+            return new core_1.ReadOnlyException(exception);
+        }
+        if (exception.message.includes('unable to open database file')) {
+            return new core_1.ConnectionException(exception);
+        }
+        if (exception.message.includes('FOREIGN KEY constraint failed')) {
+            return new core_1.ForeignKeyConstraintViolationException(exception);
+        }
+        return super.convertException(exception);
+    }
+}
+exports.SqliteExceptionConverter = SqliteExceptionConverter;

package/dialects/sqlite/SqliteNativeQueryBuilder.d.ts

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

package/dialects/sqlite/SqliteNativeQueryBuilder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteNativeQueryBuilder = void 0;
+const NativeQueryBuilder_1 = require("../../query/NativeQueryBuilder");
+/** @internal */
+class SqliteNativeQueryBuilder extends NativeQueryBuilder_1.NativeQueryBuilder {
+    compileTruncate() {
+        const sql = `delete from ${this.getTableName()}`;
+        this.parts.push(sql);
+    }
+    addLockClause() {
+        return; // not supported
+    }
+}
+exports.SqliteNativeQueryBuilder = SqliteNativeQueryBuilder;

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -0,0 +1,38 @@
+import { type Connection } from '@mikro-orm/core';
+import type { AbstractSqlConnection } from '../../AbstractSqlConnection';
+import { SchemaHelper } from '../../schema/SchemaHelper';
+import type { Column, IndexDef, Table, TableDifference } from '../../typings';
+import type { DatabaseTable } from '../../schema/DatabaseTable';
+import type { DatabaseSchema } from '../../schema/DatabaseSchema';
+export declare class SqliteSchemaHelper extends SchemaHelper {
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    supportsSchemaConstraints(): boolean;
+    getListTablesSQL(): string;
+    getDropDatabaseSQL(name: string): string;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
+    createTable(table: DatabaseTable, alter?: boolean): string[];
+    createTableColumn(column: Column, table: DatabaseTable, _changedProperties?: Set<string>): string | undefined;
+    getAddColumnsSQL(table: DatabaseTable, columns: Column[], diff?: TableDifference): string[];
+    dropForeignKey(tableName: string, constraintName: string): string;
+    getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
+    getCreateIndexSQL(tableName: string, index: IndexDef): string;
+    private parseTableDefinition;
+    private getColumns;
+    private getEnumDefinitions;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
+    private getIndexes;
+    private getChecks;
+    private getColumnDefinitions;
+    private getForeignKeys;
+    getManagementDbName(): string;
+    getCreateDatabaseSQL(name: string): string;
+    databaseExists(connection: Connection, name: string): Promise<boolean>;
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name: string): boolean;
+    dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
+    alterTable(diff: TableDifference, safe?: boolean): string[];
+    private getAlterTempTableSQL;
+}

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteSchemaHelper = void 0;
+const core_1 = require("@mikro-orm/core");
+const SchemaHelper_1 = require("../../schema/SchemaHelper");
+class SqliteSchemaHelper 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.quote(name)}`;
+    }
+    async loadInformationSchema(schema, connection, tables, schemas) {
+        for (const t of tables) {
+            const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            const cols = await this.getColumns(connection, table.name, table.schema);
+            const indexes = await this.getIndexes(connection, table.name, table.schema);
+            const checks = await this.getChecks(connection, table.name, table.schema);
+            const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
+            const fks = await this.getForeignKeys(connection, table.name, table.schema);
+            const enums = await this.getEnumDefinitions(connection, table.name);
+            table.init(cols, indexes, checks, pks, fks, enums);
+        }
+    }
+    createTable(table, alter) {
+        let sql = `create table ${table.getQuotedName()} (`;
+        const columns = table.getColumns();
+        const lastColumn = columns[columns.length - 1].name;
+        for (const column of columns) {
+            const col = this.createTableColumn(column, table);
+            if (col) {
+                const comma = column.name === lastColumn ? '' : ', ';
+                sql += col + comma;
+            }
+        }
+        const primaryKey = table.getPrimaryKey();
+        const createPrimary = primaryKey?.composite;
+        if (createPrimary && primaryKey) {
+            sql += `, primary key (${primaryKey.columnNames.map(c => this.quote(c)).join(', ')})`;
+        }
+        const parts = [];
+        for (const fk of Object.values(table.getForeignKeys())) {
+            parts.push(this.createForeignKey(table, fk, false));
+        }
+        for (const check of table.getChecks()) {
+            const sql = `constraint ${this.quote(check.name)} check (${check.expression})`;
+            parts.push(sql);
+        }
+        if (parts.length > 0) {
+            sql += ', ' + parts.join(', ');
+        }
+        sql += ')';
+        const ret = [];
+        this.append(ret, sql);
+        for (const index of table.getIndexes()) {
+            this.append(ret, this.createIndex(index, table));
+        }
+        return ret;
+    }
+    createTableColumn(column, table, _changedProperties) {
+        const col = [this.quote(column.name)];
+        const checks = table.getChecks();
+        const check = checks.findIndex(check => check.columnName === column.name);
+        const useDefault = column.default != null && column.default !== 'null';
+        let columnType = column.type;
+        if (column.autoincrement) {
+            columnType = 'integer';
+        }
+        if (column.generated) {
+            columnType += ` generated always as ${column.generated}`;
+        }
+        col.push(columnType);
+        if (check !== -1) {
+            col.push(`check (${checks[check].expression})`);
+            checks.splice(check, 1);
+        }
+        core_1.Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
+        core_1.Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
+        core_1.Utils.runIfNotEmpty(() => col.push('primary key'), column.primary);
+        core_1.Utils.runIfNotEmpty(() => col.push('autoincrement'), column.autoincrement);
+        core_1.Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
+        return col.join(' ');
+    }
+    getAddColumnsSQL(table, columns, diff) {
+        return columns.map(column => {
+            let sql = `alter table ${table.getQuotedName()} add column ${this.createTableColumn(column, table)}`;
+            const foreignKey = Object.values(diff.addedForeignKeys).find(fk => fk.columnNames.length === 1 && fk.columnNames[0] === column.name);
+            if (foreignKey && this.options.createForeignKeyConstraints) {
+                delete diff.addedForeignKeys[foreignKey.constraintName];
+                sql += ' ' + this.createForeignKey(diff.toTable, foreignKey, false, true);
+            }
+            return sql;
+        });
+    }
+    dropForeignKey(tableName, constraintName) {
+        return '';
+    }
+    getDropColumnsSQL(tableName, columns, schemaName) {
+        /* istanbul ignore next */
+        const name = this.quote((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
+        return columns.map(column => {
+            return `alter table ${name} drop column ${this.quote(column.name)}`;
+        }).join(';\n');
+    }
+    getCreateIndexSQL(tableName, index) {
+        /* istanbul ignore next */
+        if (index.expression) {
+            return index.expression;
+        }
+        tableName = this.quote(tableName);
+        const keyName = this.quote(index.keyName);
+        const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+        if (index.columnNames.some(column => column.includes('.'))) {
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+            const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+            const columns = this.platform.getJsonIndexDefinition(index);
+            return `${sql}(${columns.join(', ')})`;
+        }
+        return `${sql}(${index.columnNames.map(c => this.quote(c)).join(', ')})`;
+    }
+    parseTableDefinition(sql, cols) {
+        const columns = {};
+        const constraints = [];
+        // extract all columns definitions
+        let columnsDef = sql.replaceAll('\n', '').match(new RegExp(`create table [\`"']?.*?[\`"']? \\((.*)\\)`, 'i'))?.[1];
+        /* istanbul ignore else */
+        if (columnsDef) {
+            if (columnsDef.includes(', constraint ')) {
+                constraints.push(...columnsDef.substring(columnsDef.indexOf(', constraint') + 2).split(', '));
+                columnsDef = columnsDef.substring(0, columnsDef.indexOf(', constraint'));
+            }
+            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, constraints };
+    }
+    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 { columns: 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, tableName) {
+        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) {
+        const { columns, constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
+        const checks = [];
+        for (const key of Object.keys(columns)) {
+            const column = columns[key];
+            const expression = column.definition.match(/ (check \((.*)\))/i);
+            if (expression) {
+                checks.push({
+                    name: this.platform.getConfig().getNamingStrategy().indexName(tableName, [column.name], 'check'),
+                    definition: expression[1],
+                    expression: expression[2],
+                    columnName: column.name,
+                });
+            }
+        }
+        for (const constraint of constraints) {
+            const expression = constraint.match(/constraint *[`"']?(.*?)[`"']? * (check \((.*)\))/i);
+            if (expression) {
+                checks.push({
+                    name: expression[1],
+                    definition: expression[2],
+                    expression: expression[3],
+                });
+            }
+        }
+        return checks;
+    }
+    async getColumnDefinitions(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');
+        return this.parseTableDefinition(tableDefinition.sql, columns);
+    }
+    async getForeignKeys(connection, tableName, schemaName) {
+        const { constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
+        const fks = await connection.execute(`pragma foreign_key_list(\`${tableName}\`)`);
+        return fks.reduce((ret, fk) => {
+            const constraintName = this.platform.getIndexName(tableName, [fk.from], 'foreign');
+            const constraint = constraints?.find(c => c.includes(constraintName));
+            ret[constraintName] = {
+                constraintName,
+                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(),
+                deferMode: constraint?.match(/ deferrable initially (deferred|immediate)/i)?.[1].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_');
+    }
+    dropIndex(table, index, oldIndexName = index.keyName) {
+        return `drop index ${this.quote(oldIndexName)}`;
+    }
+    alterTable(diff, safe) {
+        const ret = [];
+        const [schemaName, tableName] = this.splitTableName(diff.name);
+        if (core_1.Utils.hasObjectKeys(diff.removedChecks)
+            || core_1.Utils.hasObjectKeys(diff.changedChecks)
+            || core_1.Utils.hasObjectKeys(diff.changedForeignKeys)
+            || core_1.Utils.hasObjectKeys(diff.changedColumns)) {
+            return this.getAlterTempTableSQL(diff);
+        }
+        for (const index of Object.values(diff.removedIndexes)) {
+            this.append(ret, this.dropIndex(diff.name, index));
+        }
+        for (const index of Object.values(diff.changedIndexes)) {
+            this.append(ret, this.dropIndex(diff.name, index));
+        }
+        /* istanbul ignore else */
+        if (!safe && Object.values(diff.removedColumns).length > 0) {
+            this.append(ret, this.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
+        }
+        if (Object.values(diff.addedColumns).length > 0) {
+            this.append(ret, this.getAddColumnsSQL(diff.toTable, Object.values(diff.addedColumns), diff));
+        }
+        if (core_1.Utils.hasObjectKeys(diff.addedForeignKeys) || core_1.Utils.hasObjectKeys(diff.addedChecks)) {
+            return this.getAlterTempTableSQL(diff);
+        }
+        for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
+            this.append(ret, this.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
+        }
+        for (const index of Object.values(diff.addedIndexes)) {
+            ret.push(this.createIndex(index, diff.toTable));
+        }
+        for (const index of Object.values(diff.changedIndexes)) {
+            ret.push(this.createIndex(index, diff.toTable, true));
+        }
+        for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {
+            if (index.unique) {
+                this.append(ret, this.dropIndex(diff.name, index, oldIndexName));
+                this.append(ret, this.createIndex(index, diff.toTable));
+            }
+            else {
+                this.append(ret, this.getRenameIndexSQL(diff.name, index, oldIndexName));
+            }
+        }
+        return ret;
+    }
+    getAlterTempTableSQL(changedTable) {
+        const tempName = `${(changedTable.toTable.name)}__temp_alter`;
+        const quotedName = this.quote(changedTable.toTable.name);
+        const quotedTempName = this.quote(tempName);
+        const [first, ...rest] = this.createTable(changedTable.toTable);
+        const sql = [
+            'pragma foreign_keys = off;',
+            first.replace(`create table ${quotedName}`, `create table ${quotedTempName}`),
+        ];
+        const columns = [];
+        for (const column of changedTable.toTable.getColumns()) {
+            const fromColumn = changedTable.fromTable.getColumn(column.name);
+            if (fromColumn) {
+                columns.push(this.quote(column.name));
+            }
+            else {
+                columns.push(`null as ${this.quote(column.name)}`);
+            }
+        }
+        sql.push(`insert into ${quotedTempName} select ${columns.join(', ')} from ${quotedName};`);
+        sql.push(`drop table ${quotedName};`);
+        sql.push(`alter table ${quotedTempName} rename to ${quotedName};`);
+        sql.push(...rest);
+        sql.push('pragma foreign_keys = on;');
+        return sql;
+    }
+}
+exports.SqliteSchemaHelper = SqliteSchemaHelper;

package/dialects/sqlite/index.d.ts

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

package/dialects/sqlite/index.js

@@ -16,8 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 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);
+__exportStar(require("./SqliteSchemaHelper"), exports);
+__exportStar(require("./SqliteNativeQueryBuilder"), exports);
+__exportStar(require("./SqliteExceptionConverter"), exports);

package/index.d.ts

@@ -5,7 +5,6 @@
 export * from './AbstractSqlConnection';
 export * from './AbstractSqlDriver';
 export * from './AbstractSqlPlatform';
-export * from './MonkeyPatchable';
 export * from './SqlEntityManager';
 export * from './SqlEntityRepository';
 export * from './query';
@@ -15,5 +14,5 @@ export * from './typings';
 export { SqlEntityManager as EntityManager } from './SqlEntityManager';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository';
 /** @ignore */
-export { Knex, knex } from 'knex';
+export { Kysely } from 'kysely';
 export * from '@mikro-orm/core';

package/index.js

@@ -14,7 +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 });
-exports.knex = exports.Knex = exports.EntityRepository = exports.EntityManager = void 0;
+exports.Kysely = exports.EntityRepository = exports.EntityManager = void 0;
 /**
  * @packageDocumentation
  * @module knex
@@ -23,7 +23,6 @@ exports.knex = exports.Knex = exports.EntityRepository = exports.EntityManager =
 __exportStar(require("./AbstractSqlConnection"), exports);
 __exportStar(require("./AbstractSqlDriver"), exports);
 __exportStar(require("./AbstractSqlPlatform"), exports);
-__exportStar(require("./MonkeyPatchable"), exports);
 __exportStar(require("./SqlEntityManager"), exports);
 __exportStar(require("./SqlEntityRepository"), exports);
 __exportStar(require("./query"), exports);
@@ -35,7 +34,6 @@ Object.defineProperty(exports, "EntityManager", { enumerable: true, get: functio
 var SqlEntityRepository_1 = require("./SqlEntityRepository");
 Object.defineProperty(exports, "EntityRepository", { enumerable: true, get: function () { return SqlEntityRepository_1.SqlEntityRepository; } });
 /** @ignore */
-var knex_1 = require("knex");
-Object.defineProperty(exports, "Knex", { enumerable: true, get: function () { return knex_1.Knex; } });
-Object.defineProperty(exports, "knex", { enumerable: true, get: function () { return knex_1.knex; } });
+var kysely_1 = require("kysely");
+Object.defineProperty(exports, "Kysely", { enumerable: true, get: function () { return kysely_1.Kysely; } });
 __exportStar(require("@mikro-orm/core"), exports);

package/index.mjs

@@ -19,12 +19,10 @@ 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;
@@ -112,14 +110,12 @@ export const JSON_KEY_OPERATORS = mod.JSON_KEY_OPERATORS;
 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 Kysely = mod.Kysely;
 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;
@@ -129,13 +125,12 @@ export const MetadataStorage = mod.MetadataStorage;
 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 MsSqlNativeQueryBuilder = mod.MsSqlNativeQueryBuilder;
 export const MySqlExceptionConverter = mod.MySqlExceptionConverter;
-export const MySqlKnexDialect = mod.MySqlKnexDialect;
+export const MySqlNativeQueryBuilder = mod.MySqlNativeQueryBuilder;
 export const MySqlPlatform = mod.MySqlPlatform;
 export const MySqlSchemaHelper = mod.MySqlSchemaHelper;
+export const NativeQueryBuilder = mod.NativeQueryBuilder;
 export const NodeState = mod.NodeState;
 export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
 export const NotFoundError = mod.NotFoundError;
@@ -155,7 +150,7 @@ 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 PostgreSqlNativeQueryBuilder = mod.PostgreSqlNativeQueryBuilder;
 export const PrimaryKey = mod.PrimaryKey;
 export const PrimaryKeyProp = mod.PrimaryKeyProp;
 export const Property = mod.Property;
@@ -167,6 +162,7 @@ export const QueryOperator = mod.QueryOperator;
 export const QueryOrder = mod.QueryOrder;
 export const QueryOrderNumeric = mod.QueryOrderNumeric;
 export const QueryType = mod.QueryType;
+export const Raw = mod.Raw;
 export const RawQueryFragment = mod.RawQueryFragment;
 export const ReadOnlyException = mod.ReadOnlyException;
 export const Ref = mod.Ref;
@@ -188,8 +184,9 @@ 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 SqliteExceptionConverter = mod.SqliteExceptionConverter;
+export const SqliteNativeQueryBuilder = mod.SqliteNativeQueryBuilder;
+export const SqliteSchemaHelper = mod.SqliteSchemaHelper;
 export const StringType = mod.StringType;
 export const SyntaxErrorException = mod.SyntaxErrorException;
 export const TableExistsException = mod.TableExistsException;
@@ -223,7 +220,7 @@ export const equals = mod.equals;
 export const getOnConflictFields = mod.getOnConflictFields;
 export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
 export const helper = mod.helper;
-export const knex = mod.knex;
+export const isRaw = mod.isRaw;
 export const parseJsonSafe = mod.parseJsonSafe;
 export const raw = mod.raw;
 export const ref = mod.ref;