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

package/dialects/mssql/MsSqlKnexDialect.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MsSqlKnexDialect = void 0;
-const MonkeyPatchable_1 = require("../../MonkeyPatchable");
-const MsSqlTableCompiler_1 = require("./MsSqlTableCompiler");
-const MsSqlColumnCompiler_1 = require("./MsSqlColumnCompiler");
-const MsSqlQueryCompiler_1 = require("./MsSqlQueryCompiler");
-class MsSqlKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.MsSqlDialect {
-    tableCompiler() {
-        // eslint-disable-next-line prefer-rest-params
-        return new MsSqlTableCompiler_1.MsSqlTableCompiler(this, ...arguments);
-    }
-    columnCompiler() {
-        // eslint-disable-next-line prefer-rest-params
-        return new MsSqlColumnCompiler_1.MsSqlColumnCompiler(this, ...arguments);
-    }
-    queryCompiler() {
-        // eslint-disable-next-line prefer-rest-params
-        return new MsSqlQueryCompiler_1.MsSqlQueryCompiler(this, ...arguments);
-    }
-}
-exports.MsSqlKnexDialect = MsSqlKnexDialect;

package/dialects/mssql/MsSqlQueryCompiler.d.ts

@@ -1,12 +0,0 @@
-import { MonkeyPatchable } from '../../MonkeyPatchable';
-export declare class MsSqlQueryCompiler extends MonkeyPatchable.MsSqlQueryCompiler {
-    constructor(client: any, builder: any, formatter: any);
-    insert(this: any): any;
-    _mergeAnd(this: any): string;
-    _mergeWhenMatched(this: any, columns: any, updates: any): string;
-    _mergeWhenNotMatched(this: any, columns: any): string;
-    _getParameters(this: any, params: any): any;
-    _mergeInsertIsEmpty(this: any, insert: any): boolean;
-    _mergeOn(this: any, conflict: any): string;
-    _insertWithMerge(this: any): string;
-}

package/dialects/mssql/MsSqlQueryCompiler.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MsSqlQueryCompiler = void 0;
-/* istanbul ignore file */
-const MonkeyPatchable_1 = require("../../MonkeyPatchable");
-const core_1 = require("@mikro-orm/core");
-// upsert support from https://github.com/knex/knex/pull/6050
-class MsSqlQueryCompiler extends MonkeyPatchable_1.MonkeyPatchable.MsSqlQueryCompiler {
-    constructor(client, builder, formatter) {
-        const onConflict = builder._single.onConflict;
-        delete builder._single.onConflict;
-        super(client, builder, formatter);
-        this.single.onConflict = onConflict;
-    }
-    // Compiles an "insert" query, allowing for multiple
-    // inserts using a single query statement.
-    insert() {
-        if (this.single.onConflict) {
-            return this._insertWithMerge();
-        }
-        return super.insert();
-    }
-    _mergeAnd() {
-        const wheres = this.where();
-        if (!wheres) {
-            return '';
-        }
-        return `and ${wheres.slice(6)} `;
-    }
-    _mergeWhenMatched(columns, updates) {
-        let columnsData = [];
-        if (!updates || Array.isArray(updates)) {
-            columnsData = columns
-                .map((column) => `${this.formatter.columnize(column)}=tsource.${this.formatter.columnize(column)}`)
-                .join(', ');
-        }
-        if (typeof updates === 'string') {
-            columnsData = `${this.formatter.columnize(updates)}=tsource.${this.formatter.columnize(updates)}`;
-        }
-        if (!Array.isArray(updates) && typeof updates === 'object') {
-            columnsData = Object.entries(updates)
-                .map(([key, value]) => `${this.tableName}.${this.formatter.columnize(key)}=(${this._getParameters([value])})`);
-        }
-        const sql = ` when matched ${this._mergeAnd()}then update set ${columnsData}`;
-        return sql;
-    }
-    _mergeWhenNotMatched(columns) {
-        const destinationColumns = this.formatter.columnize(columns);
-        const sourceColumns = this.formatter.columnizeWithPrefix('tsource.', columns);
-        const sql = ` when not matched then insert (${destinationColumns}) values (${sourceColumns})`;
-        return sql;
-    }
-    _getParameters(params) {
-        const sql = this.client.parameterize(params, this.client.valueForUndefined, this.builder, this.bindingsHolder);
-        return sql;
-    }
-    _mergeInsertIsEmpty(insert) {
-        return (Array.isArray(insert) && insert.length === 0)
-            || (typeof insert === 'object' && core_1.Utils.isEmpty(insert));
-    }
-    _mergeOn(conflict) {
-        let sql = 'on 1=1';
-        if (Array.isArray(conflict)) {
-            const conflictColumn = this.formatter.columnize(conflict[0]);
-            sql = `on ${this.tableName}.${conflictColumn} = tsource.${conflictColumn}`;
-        }
-        return sql;
-    }
-    _insertWithMerge() {
-        const { insert = [], onConflict, ignore, merge, returning, options = {} } = this.single;
-        if (this._mergeInsertIsEmpty(insert)) {
-            return '';
-        }
-        const insertData = this._prepInsert(insert);
-        const insertParameters = insertData.values.map((value) => `(${this._getParameters(value)})`).join(', ');
-        const sourceColumns = this.formatter.columnize(insertData.columns);
-        const returningSql = returning
-            ? ` ${this._returning('insert', returning, options.includeTriggerModifications)}`
-            : '';
-        let sql = `merge into ${this.tableName} using (values ${insertParameters}) as tsource(${sourceColumns}) `;
-        sql += this._mergeOn(onConflict);
-        sql += this._mergeWhenNotMatched(insertData.columns);
-        if (!ignore) {
-            sql += this._mergeWhenMatched(insertData.columns, merge.updates);
-        }
-        sql += returningSql;
-        if (options.includeTriggerModifications) {
-            sql = this._buildTempTable(returning) + sql + this._buildReturningSelect(returning);
-        }
-        sql = this.with() + sql + ';';
-        return sql;
-    }
-}
-exports.MsSqlQueryCompiler = MsSqlQueryCompiler;

package/dialects/mssql/MsSqlTableCompiler.d.ts

@@ -1,9 +0,0 @@
-import { MonkeyPatchable } from '../../MonkeyPatchable';
-export declare class MsSqlTableCompiler extends MonkeyPatchable.MsSqlTableCompiler {
-    lowerCase: boolean;
-    addColumnsPrefix: string;
-    dropColumnPrefix: string;
-    alterColumnPrefix: string;
-    alterColumns(this: any, columns: any, colBuilder: any): void;
-    dropForeign(this: any, columns: any, constraintName: any): void;
-}

package/dialects/mssql/MsSqlTableCompiler.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MsSqlTableCompiler = void 0;
-const MonkeyPatchable_1 = require("../../MonkeyPatchable");
-class MsSqlTableCompiler extends MonkeyPatchable_1.MonkeyPatchable.MsSqlTableCompiler {
-    lowerCase = true;
-    addColumnsPrefix = 'add ';
-    dropColumnPrefix = 'drop column ';
-    alterColumnPrefix = 'alter column ';
-    alterColumns(columns, colBuilder) {
-        for (let i = 0, l = colBuilder.length; i < l; i++) {
-            const builder = colBuilder[i];
-            if (builder.modified.defaultTo) {
-                const schema = this.schemaNameRaw || 'dbo';
-                const baseQuery = `declare @constraint${i} varchar(100) = (select default_constraints.name from sys.all_columns`
-                    + ' join sys.tables on all_columns.object_id = tables.object_id'
-                    + ' join sys.schemas on tables.schema_id = schemas.schema_id'
-                    + ' join sys.default_constraints on all_columns.default_object_id = default_constraints.object_id'
-                    + ` where schemas.name = '${schema}' and tables.name = '${this.tableNameRaw}' and all_columns.name = '${builder.getColumnName()}')`
-                    + ` if @constraint${i} is not null exec('alter table ${this.tableNameRaw} drop constraint ' + @constraint${i})`;
-                this.pushQuery(baseQuery);
-            }
-        }
-        // in SQL server only one column can be altered at a time
-        columns.sql.forEach((sql) => {
-            this.pushQuery({
-                sql: `alter table ${this.tableName()} ${this.alterColumnPrefix.toLowerCase()}${sql}`,
-                bindings: columns.bindings,
-            });
-        });
-    }
-    dropForeign(columns, constraintName) {
-        /* istanbul ignore next */
-        constraintName = constraintName
-            ? this.formatter.wrap(constraintName)
-            : this._indexCommand('foreign', this.tableNameRaw, columns);
-        this.pushQuery(`alter table ${this.tableName()} drop constraint ${constraintName}`);
-    }
-}
-exports.MsSqlTableCompiler = MsSqlTableCompiler;

package/dialects/mysql/MariaDbKnexDialect.d.ts

@@ -1,6 +0,0 @@
-import { MySqlKnexDialect } from './MySqlKnexDialect';
-export declare class MariaDbKnexDialect extends MySqlKnexDialect {
-    get driverName(): string;
-    _driver(): any;
-    validateConnection(connection: any): any;
-}

package/dialects/mysql/MariaDbKnexDialect.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MariaDbKnexDialect = void 0;
-const MySqlKnexDialect_1 = require("./MySqlKnexDialect");
-class MariaDbKnexDialect extends MySqlKnexDialect_1.MySqlKnexDialect {
-    get driverName() {
-        return 'mariadb';
-    }
-    _driver() {
-        return require('mariadb/callback');
-    }
-    validateConnection(connection) {
-        return connection.isValid();
-    }
-}
-exports.MariaDbKnexDialect = MariaDbKnexDialect;

package/dialects/mysql/MySqlColumnCompiler.d.ts

@@ -1,7 +0,0 @@
-import BaseMySqlColumnCompiler from 'knex/lib/dialects/mysql/schema/mysql-columncompiler';
-import type { MySqlIncrementOptions } from '../../typings';
-export declare class MySqlColumnCompiler extends BaseMySqlColumnCompiler {
-    increments(options: MySqlIncrementOptions): string;
-    bigincrements(options: MySqlIncrementOptions): string;
-    private generateDDL;
-}

package/dialects/mysql/MySqlColumnCompiler.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MySqlColumnCompiler = void 0;
-// @ts-ignore
-const mysql_columncompiler_1 = __importDefault(require("knex/lib/dialects/mysql/schema/mysql-columncompiler"));
-class MySqlColumnCompiler extends mysql_columncompiler_1.default {
-    // we need the old behaviour to be able to add auto_increment to a column that is already PK
-    increments(options) {
-        return this.generateDDL(options);
-    }
-    /* istanbul ignore next */
-    bigincrements(options) {
-        return this.generateDDL(options);
-    }
-    generateDDL(options = {}) {
-        const { primaryKey = true, unsigned = true, type = 'int' } = options;
-        return type
-            + (unsigned ? ' unsigned' : '')
-            + ' not null auto_increment'
-            + (this.tableCompiler._canBeAddPrimaryKey({ primaryKey }) ? ' primary key' : '');
-    }
-}
-exports.MySqlColumnCompiler = MySqlColumnCompiler;

package/dialects/mysql/MySqlConnection.d.ts

@@ -1,8 +0,0 @@
-import type { Knex } from 'knex';
-import { AbstractSqlConnection } from '../../AbstractSqlConnection';
-export declare class MySqlConnection extends AbstractSqlConnection {
-    createKnex(): void;
-    getDefaultClientUrl(): string;
-    getConnectionOptions(): Knex.MySqlConnectionConfig;
-    protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
-}

package/dialects/mysql/MySqlConnection.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MySqlConnection = void 0;
-const MySqlKnexDialect_1 = require("./MySqlKnexDialect");
-const AbstractSqlConnection_1 = require("../../AbstractSqlConnection");
-class MySqlConnection extends AbstractSqlConnection_1.AbstractSqlConnection {
-    createKnex() {
-        this.client = this.createKnexClient(MySqlKnexDialect_1.MySqlKnexDialect);
-        this.connected = true;
-    }
-    getDefaultClientUrl() {
-        return 'mysql://root@127.0.0.1:3306';
-    }
-    getConnectionOptions() {
-        const ret = super.getConnectionOptions();
-        if (this.config.get('multipleStatements')) {
-            ret.multipleStatements = this.config.get('multipleStatements');
-        }
-        if (this.config.get('forceUtcTimezone')) {
-            ret.timezone = 'Z';
-        }
-        if (this.config.get('timezone')) {
-            ret.timezone = this.config.get('timezone');
-        }
-        ret.supportBigNumbers = true;
-        ret.dateStrings = true;
-        return ret;
-    }
-    transformRawResult(res, method) {
-        if (method === 'run' && ['OkPacket', 'ResultSetHeader'].includes(res[0].constructor.name)) {
-            return {
-                insertId: res[0].insertId,
-                affectedRows: res[0].affectedRows,
-                rows: [],
-            };
-        }
-        if (method === 'get') {
-            return res[0][0];
-        }
-        return res[0];
-    }
-}
-exports.MySqlConnection = MySqlConnection;

package/dialects/mysql/MySqlKnexDialect.d.ts

@@ -1,5 +0,0 @@
-import { MonkeyPatchable } from '../../MonkeyPatchable';
-export declare class MySqlKnexDialect extends MonkeyPatchable.MySqlDialect {
-    queryCompiler(): any;
-    columnCompiler(): any;
-}

package/dialects/mysql/MySqlKnexDialect.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MySqlKnexDialect = void 0;
-const MySqlQueryCompiler_1 = require("./MySqlQueryCompiler");
-const MySqlColumnCompiler_1 = require("./MySqlColumnCompiler");
-const MonkeyPatchable_1 = require("../../MonkeyPatchable");
-class MySqlKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.MySqlDialect {
-    queryCompiler() {
-        // eslint-disable-next-line prefer-rest-params
-        return new MySqlQueryCompiler_1.MySqlQueryCompiler(this, ...arguments);
-    }
-    columnCompiler() {
-        // eslint-disable-next-line prefer-rest-params
-        return new MySqlColumnCompiler_1.MySqlColumnCompiler(this, ...arguments);
-    }
-}
-exports.MySqlKnexDialect = MySqlKnexDialect;

package/dialects/mysql/MySqlQueryCompiler.d.ts

@@ -1,5 +0,0 @@
-import BaseMySqlQueryCompiler from 'knex/lib/dialects/mysql/query/mysql-querycompiler';
-export declare class MySqlQueryCompiler extends BaseMySqlQueryCompiler {
-    whereBasic(statement: any): any;
-    whereRaw(statement: any): any;
-}

package/dialects/mysql/MySqlQueryCompiler.js

@@ -1,23 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MySqlQueryCompiler = void 0;
-/* istanbul ignore file */
-// @ts-ignore
-const mysql_querycompiler_1 = __importDefault(require("knex/lib/dialects/mysql/query/mysql-querycompiler"));
-// @ts-ignore
-const querycompiler_1 = __importDefault(require("knex/lib/query/querycompiler"));
-// upsert support from https://github.com/knex/knex/pull/6050
-class MySqlQueryCompiler extends mysql_querycompiler_1.default {
-    // mysql dialect disallows query non scalar params, but we dont use it to execute the query, it always goes through the `platform.formatQuery()`
-    whereBasic(statement) {
-        return querycompiler_1.default.prototype.whereBasic.call(this, statement);
-    }
-    // mysql dialect disallows query non scalar params, but we dont use it to execute the query, it always goes through the `platform.formatQuery()`
-    whereRaw(statement) {
-        return querycompiler_1.default.prototype.whereRaw.call(this, statement);
-    }
-}
-exports.MySqlQueryCompiler = MySqlQueryCompiler;

package/dialects/postgresql/PostgreSqlKnexDialect.d.ts

@@ -1,7 +0,0 @@
-import type { Configuration } from '@mikro-orm/core';
-import { MonkeyPatchable } from '../../MonkeyPatchable';
-export declare class PostgreSqlKnexDialect extends MonkeyPatchable.PostgresDialect {
-    ormConfig: Configuration;
-    tableCompiler(): any;
-    queryCompiler(): any;
-}

package/dialects/postgresql/PostgreSqlKnexDialect.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgreSqlKnexDialect = void 0;
-const PostgreSqlTableCompiler_1 = require("./PostgreSqlTableCompiler");
-const PostgreSqlQueryCompiler_1 = require("./PostgreSqlQueryCompiler");
-const MonkeyPatchable_1 = require("../../MonkeyPatchable");
-class PostgreSqlKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.PostgresDialect {
-    ormConfig;
-    tableCompiler() {
-        // eslint-disable-next-line prefer-rest-params
-        const tableCompiler = new PostgreSqlTableCompiler_1.PostgreSqlTableCompiler(this, ...arguments);
-        tableCompiler.ormConfig = this.ormConfig;
-        return tableCompiler;
-    }
-    queryCompiler() {
-        // eslint-disable-next-line prefer-rest-params
-        return new PostgreSqlQueryCompiler_1.PostgreSqlQueryCompiler(this, ...arguments);
-    }
-}
-exports.PostgreSqlKnexDialect = PostgreSqlKnexDialect;

package/dialects/postgresql/PostgreSqlQueryCompiler.d.ts

@@ -1,4 +0,0 @@
-import { MonkeyPatchable } from '../../MonkeyPatchable';
-export declare class PostgreSqlQueryCompiler extends MonkeyPatchable.PostgresQueryCompiler {
-    _lockingClause(this: any, lockMode: string): string;
-}

package/dialects/postgresql/PostgreSqlQueryCompiler.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgreSqlQueryCompiler = void 0;
-const MonkeyPatchable_1 = require("../../MonkeyPatchable");
-class PostgreSqlQueryCompiler extends MonkeyPatchable_1.MonkeyPatchable.PostgresQueryCompiler {
-    _lockingClause(lockMode) {
-        const tables = this.single.lockTables || [];
-        return lockMode + (tables.length
-            ? ' of ' + tables.filter(Boolean).map((table) => this.formatter.wrap(table)).join(', ')
-            : '');
-    }
-}
-exports.PostgreSqlQueryCompiler = PostgreSqlQueryCompiler;

package/dialects/postgresql/PostgreSqlTableCompiler.d.ts

@@ -1,11 +0,0 @@
-import PostgresDialectTableCompiler from 'knex/lib/dialects/postgres/schema/pg-tablecompiler';
-import type { Configuration, Dictionary } from '@mikro-orm/core';
-export declare class PostgreSqlTableCompiler extends PostgresDialectTableCompiler {
-    ormConfig: Configuration;
-    alterColumnsPrefix: string;
-    addColumns(columns: Dictionary[], prefix: string, colCompilers: Dictionary[]): any;
-    private addColumn;
-    private alterColumnNullable;
-    private addColumnDefault;
-    private dropColumnDefault;
-}

package/dialects/postgresql/PostgreSqlTableCompiler.js

@@ -1,89 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgreSqlTableCompiler = void 0;
-// @ts-ignore
-const pg_tablecompiler_1 = __importDefault(require("knex/lib/dialects/postgres/schema/pg-tablecompiler"));
-// @ts-ignore
-const tablecompiler_1 = __importDefault(require("knex/lib/schema/tablecompiler"));
-class PostgreSqlTableCompiler extends pg_tablecompiler_1.default {
-    ormConfig;
-    addColumns(columns, prefix, colCompilers) {
-        if (prefix !== this.alterColumnsPrefix) {
-            // base class implementation for normal add
-            return tablecompiler_1.default.prototype.addColumns.call(this, columns, prefix);
-        }
-        // alter columns
-        for (const col of colCompilers) {
-            this.addColumn(col);
-        }
-    }
-    addColumn(col) {
-        const options = this.ormConfig.get('schemaGenerator');
-        const quotedTableName = this.tableName();
-        const type = col.getColumnType();
-        const colName = this.client.wrapIdentifier(col.getColumnName(), col.columnBuilder.queryContext());
-        const constraintName = `${this.tableNameRaw.replace(/^.*\.(.*)$/, '$1')}_${col.getColumnName()}_check`;
-        const useNative = col.args?.[2]?.useNative;
-        const alterType = col.columnBuilder.alterType;
-        const alterNullable = col.columnBuilder.alterNullable;
-        const defaultTo = col.modified.defaultTo;
-        if (defaultTo != null) {
-            this.dropColumnDefault(col, colName);
-        }
-        /* istanbul ignore next */
-        if (col.type === 'enu' && !useNative) {
-            if (alterType) {
-                this.pushQuery({ sql: `alter table ${quotedTableName} alter column ${colName} type text using (${colName}::text)`, bindings: [] });
-            }
-            /* istanbul ignore else */
-            if (options.createForeignKeyConstraints && alterNullable) {
-                this.pushQuery({ sql: `alter table ${quotedTableName} add constraint "${constraintName}" ${type.replace(/^text /, '')}`, bindings: [] });
-            }
-        }
-        else if (type === 'uuid') {
-            // we need to drop the default as it would be invalid
-            this.pushQuery({ sql: `alter table ${quotedTableName} alter column ${colName} drop default`, bindings: [] });
-            this.pushQuery({ sql: `alter table ${quotedTableName} alter column ${colName} type ${type} using (${colName}::text::uuid)`, bindings: [] });
-        }
-        else if (alterType) {
-            this.pushQuery({ sql: `alter table ${quotedTableName} alter column ${colName} type ${type} using (${colName}::${type})`, bindings: [] });
-        }
-        this.addColumnDefault(col, colName);
-        this.alterColumnNullable(col, colName);
-    }
-    alterColumnNullable(col, colName) {
-        const quotedTableName = this.tableName();
-        const nullable = col.modified.nullable;
-        if (!nullable) {
-            return;
-        }
-        if (nullable[0] === false) {
-            this.pushQuery({ sql: `alter table ${quotedTableName} alter column ${colName} set not null`, bindings: [] });
-        }
-        else {
-            this.pushQuery({ sql: `alter table ${quotedTableName} alter column ${colName} drop not null`, bindings: [] });
-        }
-    }
-    addColumnDefault(col, colName) {
-        const quotedTableName = this.tableName();
-        const defaultTo = col.modified.defaultTo;
-        if (!defaultTo) {
-            return;
-        }
-        if (defaultTo[0] !== null) {
-            const modifier = col.defaultTo(...defaultTo);
-            this.pushQuery({ sql: `alter table ${quotedTableName} alter column ${colName} set ${modifier}`, bindings: [] });
-        }
-    }
-    dropColumnDefault(col, colName) {
-        const quotedTableName = this.tableName();
-        const defaultTo = col.modified.defaultTo;
-        if (defaultTo?.[0] == null) {
-            this.pushQuery({ sql: `alter table ${quotedTableName} alter column ${colName} drop default`, bindings: [] });
-        }
-    }
-}
-exports.PostgreSqlTableCompiler = PostgreSqlTableCompiler;

package/dialects/sqlite/BaseSqliteSchemaHelper.d.ts

@@ -1,28 +0,0 @@
-import type { Connection, Dictionary } from '@mikro-orm/core';
-import type { AbstractSqlConnection } from '../../AbstractSqlConnection';
-import { SchemaHelper } from '../../schema/SchemaHelper';
-import type { CheckDef, Column, IndexDef, TableDifference } 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;
-    getAlterTable(changedTable: TableDifference, wrap?: boolean): Promise<string>;
-}