@mikro-orm/knex 6.2.10-dev.73 → 6.2.10-dev.74

package/dialects/sqlite/LibSqlKnexDialect.d.ts

@@ -2,5 +2,10 @@ 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

@@ -10,9 +10,76 @@ class LibSqlKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.BetterSqlite3D
     _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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.2.10-dev.73",
+  "version": "6.2.10-dev.74",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.2.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.2.10-dev.73",
+    "@mikro-orm/core": "6.2.10-dev.74",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/schema/DatabaseTable.js

@@ -70,17 +70,11 @@ class DatabaseTable {
                     prop.length = undefined;
                 }
             }
-            if (mappedType instanceof core_1.DateTimeType || mappedType instanceof core_1.IntervalType) {
-                const match = prop.columnTypes[idx].match(/\w+\((\d+)\)/);
-                if (match) {
-                    prop.length ??= +match[1];
-                }
-                else {
-                    prop.length ??= this.platform.getDefaultDateTimeLength();
-                }
-            }
             if (prop.length == null && prop.columnTypes[idx]) {
                 prop.length = this.platform.getSchemaHelper().inferLengthFromColumnType(prop.columnTypes[idx]);
+                if (typeof mappedType.getDefaultLength !== 'undefined') {
+                    prop.length ??= mappedType.getDefaultLength(this.platform);
+                }
             }
             const primary = !meta.compositePK && !!prop.primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType);
             this.columns[field] = {

package/schema/SchemaHelper.js

@@ -30,7 +30,11 @@ class SchemaHelper {
         return core_1.Utils.flatten(pks);
     }
     inferLengthFromColumnType(type) {
-        return undefined;
+        const match = type.match(/^\w+\s*(?:\(\s*(\d+)\s*\)|$)/);
+        if (!match) {
+            return;
+        }
+        return +match[1];
     }
     async getForeignKeys(connection, tableName, schemaName) {
         const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));