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

package/dialects/sqlite/BaseSqliteSchemaHelper.js

@@ -1,200 +0,0 @@
-"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_');
-    }
-    async getAlterTable(changedTable, wrap) {
-        const tempName = `${(changedTable.toTable.name)}__temp_alter`;
-        const quotedName = this.platform.quoteIdentifier(changedTable.toTable.name);
-        const quotedTempName = this.platform.quoteIdentifier(tempName);
-        const createSql = await this.dump(this.createTable(changedTable.toTable), '');
-        const [first, ...rest] = createSql.split('\n');
-        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);
-            /* istanbul ignore else */
-            if (fromColumn) {
-                columns.push(this.platform.quoteIdentifier(column.name));
-            }
-            else {
-                columns.push(`null as ${this.platform.quoteIdentifier(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.join('\n');
-    }
-}
-exports.BaseSqliteSchemaHelper = BaseSqliteSchemaHelper;

package/dialects/sqlite/BetterSqliteKnexDialect.d.ts

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

package/dialects/sqlite/BetterSqliteKnexDialect.js

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

@@ -1,11 +0,0 @@
-import { MonkeyPatchable } from '../../MonkeyPatchable';
-export declare class LibSqlKnexDialect extends MonkeyPatchable.BetterSqlite3Dialect {
-    get driverName(): string;
-    _driver(): any;
-    _query(this: any, connection: any, obj: any): Promise<any>;
-    acquireRawConnection(this: any): Promise<any>;
-    tableCompiler(): any;
-    validateConnection(connection: any): boolean;
-    private getCallMethod;
-    private isRunQuery;
-}

package/dialects/sqlite/LibSqlKnexDialect.js

@@ -1,85 +0,0 @@
-"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');
-    }
-    async _query(connection, obj) {
-        /* istanbul ignore next */
-        if (!obj.sql) {
-            throw new Error('The query is empty');
-        }
-        /* istanbul ignore next */
-        if (!connection) {
-            throw new Error('No connection provided');
-        }
-        const callMethod = this.getCallMethod(obj);
-        const statement = connection.prepare(obj.sql);
-        const bindings = this._formatBindings(obj.bindings);
-        const response = await statement[callMethod](bindings);
-        obj.response = response;
-        obj.context = {
-            lastID: response.lastInsertRowid,
-            changes: response.changes,
-        };
-        return obj;
-    }
-    async acquireRawConnection() {
-        const connection = new this.driver(this.connectionSettings.filename, {
-            ...this.connectionSettings,
-        });
-        connection.__created = Date.now();
-        return connection;
-    }
-    tableCompiler() {
-        // eslint-disable-next-line prefer-rest-params
-        return new SqliteTableCompiler_1.SqliteTableCompiler(this, ...arguments);
-    }
-    validateConnection(connection) {
-        if (connection.memory) {
-            return true;
-        }
-        /* istanbul ignore next */
-        return connection.__created > Date.now() - 10_000;
-    }
-    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();
-        /* istanbul ignore next */
-        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.LibSqlKnexDialect = LibSqlKnexDialect;

package/dialects/sqlite/SqliteKnexDialect.d.ts

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

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

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

package/dialects/sqlite/SqliteTableCompiler.js

@@ -1,71 +0,0 @@
-"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);
-                },
-            });
-        }
-    }
-    foreignKeys() {
-        let sql = '';
-        const foreignKeys = (this.grouped.alterTable || []).filter((o) => o.method === 'foreign');
-        for (let i = 0, l = foreignKeys.length; i < l; i++) {
-            const foreign = foreignKeys[i].args[0];
-            const column = this.formatter.columnize(foreign.column);
-            const references = this.formatter.columnize(foreign.references);
-            const foreignTable = this.formatter.wrap(foreign.inTable);
-            /* istanbul ignore next */
-            let constraintName = foreign.keyName || '';
-            if (constraintName) {
-                constraintName = ' constraint ' + this.formatter.wrap(constraintName);
-            }
-            sql += `,${constraintName} foreign key(${column}) references ${foreignTable}(${references})`;
-            if (foreign.onDelete) {
-                sql += ` on delete ${foreign.onDelete}`;
-            }
-            if (foreign.onUpdate) {
-                sql += ` on update ${foreign.onUpdate}`;
-            }
-            if (foreign.deferrable) {
-                sql += ` deferrable initially ${foreign.deferrable}`;
-            }
-        }
-        return sql;
-    }
-}
-exports.SqliteTableCompiler = SqliteTableCompiler;