@mikro-orm/knex 6.1.13-dev.9 → 6.2.0

package/dialects/postgresql/PostgreSqlKnexDialect.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSqlKnexDialect = void 0;
+// @ts-ignore
+const postgres_1 = __importDefault(require("knex/lib/dialects/postgres"));
+const PostgreSqlTableCompiler_1 = require("./PostgreSqlTableCompiler");
+class PostgreSqlKnexDialect extends postgres_1.default {
+    ormConfig;
+    tableCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        const tableCompiler = new PostgreSqlTableCompiler_1.PostgreSqlTableCompiler(this, ...arguments);
+        tableCompiler.ormConfig = this.ormConfig;
+        return tableCompiler;
+    }
+}
+exports.PostgreSqlKnexDialect = PostgreSqlKnexDialect;

package/dialects/postgresql/PostgreSqlTableCompiler.d.ts

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

@@ -0,0 +1,89 @@
+"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/postgresql/index.d.ts

@@ -0,0 +1 @@
+export * from './PostgreSqlKnexDialect';

package/dialects/postgresql/index.js

@@ -0,0 +1,17 @@
+"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("./PostgreSqlKnexDialect"), exports);

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -0,0 +1,10 @@
+import type { Knex } from 'knex';
+import { AbstractSqlConnection } from '../../AbstractSqlConnection';
+export declare abstract class BaseSqliteConnection extends AbstractSqlConnection {
+    connect(): Promise<void>;
+    getDefaultClientUrl(): string;
+    getClientUrl(): string;
+    loadFile(path: string): Promise<void>;
+    protected getKnexOptions(type: string): Knex.Config;
+    protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
+}

package/dialects/sqlite/BaseSqliteConnection.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSqliteConnection = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const AbstractSqlConnection_1 = require("../../AbstractSqlConnection");
+const core_1 = require("@mikro-orm/core");
+class BaseSqliteConnection extends AbstractSqlConnection_1.AbstractSqlConnection {
+    async connect() {
+        this.createKnex();
+        await (0, fs_extra_1.ensureDir)((0, path_1.dirname)(this.config.get('dbName')));
+        await this.client.raw('pragma foreign_keys = on');
+    }
+    getDefaultClientUrl() {
+        return '';
+    }
+    getClientUrl() {
+        return '';
+    }
+    async loadFile(path) {
+        const conn = await this.client.client.acquireConnection();
+        await conn.exec((await (0, fs_extra_1.readFile)(path)).toString());
+        await this.client.client.releaseConnection(conn);
+    }
+    getKnexOptions(type) {
+        return core_1.Utils.mergeConfig({
+            client: type,
+            connection: {
+                filename: this.config.get('dbName'),
+            },
+            pool: this.config.get('pool'),
+            useNullAsDefault: true,
+        }, this.config.get('driverOptions'));
+    }
+    transformRawResult(res, method) {
+        if (method === 'get') {
+            return res[0];
+        }
+        if (method === 'all') {
+            return res;
+        }
+        if (Array.isArray(res)) {
+            return {
+                insertId: res[res.length - 1]?.id ?? 0,
+                affectedRows: res.length,
+                row: res[0],
+                rows: res,
+            };
+        }
+        return {
+            insertId: res.lastInsertRowid,
+            affectedRows: res.changes,
+        };
+    }
+}
+exports.BaseSqliteConnection = BaseSqliteConnection;

package/dialects/sqlite/BaseSqlitePlatform.d.ts

@@ -0,0 +1,49 @@
+import { AbstractSqlPlatform } from '../../AbstractSqlPlatform';
+export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
+    usesDefaultKeyword(): boolean;
+    usesReturningStatement(): boolean;
+    getCurrentTimestampSQL(length: number): string;
+    getDateTimeTypeDeclarationSQL(column: {
+        length: number;
+    }): string;
+    getEnumTypeDeclarationSQL(column: {
+        items?: unknown[];
+        fieldNames: string[];
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getTinyIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getSmallIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getIntegerTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getFloatDeclarationSQL(): string;
+    getBooleanTypeDeclarationSQL(): string;
+    getVarcharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    convertsJsonAutomatically(): boolean;
+    allowsComparingTuples(): boolean;
+    /**
+     * This is used to narrow the value of Date properties as they will be stored as timestamps in sqlite.
+     * We use this method to convert Dates to timestamps when computing the changeset, so we have the right
+     * data type in the payload as well as in original entity data. Without that, we would end up with diffs
+     * including all Date properties, as we would be comparing Date object with timestamp.
+     */
+    processDateProperty(value: unknown): string | number | Date;
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    getDefaultPrimaryName(tableName: string, columns: string[]): string;
+    supportsDownMigrations(): boolean;
+    getFullTextWhereClause(): string;
+}

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;