@mikro-orm/libsql 6.4.7-dev.1 → 7.0.0-dev.1

package/LibSqlConnection.d.ts

@@ -1,5 +1,8 @@
-import { BaseSqliteConnection, type Knex } from '@mikro-orm/knex';
+import { BaseSqliteConnection, type Dictionary } from '@mikro-orm/knex';
+import { type Options } from 'libsql';
+import { LibSqlDialect } from './LibSqlDialect';
 export declare class LibSqlConnection extends BaseSqliteConnection {
-    createKnex(): void;
-    protected getKnexOptions(type: string): Knex.Config;
+    private database;
+    createKyselyDialect(options: Dictionary & Options): LibSqlDialect;
+    loadFile(path: string): Promise<void>;
 }

package/LibSqlConnection.js

@@ -1,22 +1,28 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LibSqlConnection = void 0;
 const knex_1 = require("@mikro-orm/knex");
+const fs_extra_1 = require("fs-extra");
+const libsql_1 = __importDefault(require("libsql"));
+const LibSqlDialect_1 = require("./LibSqlDialect");
 class LibSqlConnection extends knex_1.BaseSqliteConnection {
-    createKnex() {
-        this.client = this.createKnexClient(knex_1.LibSqlKnexDialect);
-        this.connected = true;
-    }
-    getKnexOptions(type) {
-        return knex_1.Utils.mergeConfig({
-            client: type,
-            connection: {
-                filename: this.config.get('dbName'),
-                authToken: this.config.get('password'),
+    database;
+    createKyselyDialect(options) {
+        const dbName = options.url ?? this.config.get('dbName');
+        options.authToken ??= this.config.get('password');
+        return new LibSqlDialect_1.LibSqlDialect({
+            database: async () => {
+                return this.database = new libsql_1.default(dbName, options);
             },
-            pool: this.config.get('pool'),
-            useNullAsDefault: true,
-        }, this.config.get('driverOptions'));
+            onCreateConnection: this.options.onCreateConnection ?? this.config.get('onCreateConnection'),
+        });
+    }
+    /* istanbul ignore next */
+    async loadFile(path) {
+        this.database.exec((await (0, fs_extra_1.readFile)(path)).toString());
     }
 }
 exports.LibSqlConnection = LibSqlConnection;

package/LibSqlDialect.d.ts

@@ -0,0 +1,27 @@
+import { type DatabaseConnection, type QueryResult, type SqliteDatabase, SqliteDialect, type SqliteDialectConfig, SqliteDriver } from 'kysely';
+declare class LibSqlConnection implements DatabaseConnection {
+    private readonly db;
+    private readonly created;
+    memory: boolean;
+    constructor(db: SqliteDatabase);
+    isValid(): boolean;
+    executeQuery<R>(compiledQuery: any): Promise<QueryResult<R>>;
+    streamQuery<R>(compiledQuery: any): AsyncIterableIterator<QueryResult<R>>;
+}
+declare class LibSqlKyselyDriver extends SqliteDriver {
+    private readonly config;
+    private db;
+    private connection;
+    private connectionMutex;
+    constructor(config: SqliteDialectConfig);
+    init(): Promise<void>;
+    acquireConnection(): Promise<LibSqlConnection>;
+    releaseConnection(): Promise<void>;
+    destroy(): Promise<void>;
+}
+export declare class LibSqlDialect extends SqliteDialect {
+    private readonly config;
+    constructor(config: SqliteDialectConfig);
+    createDriver(): LibSqlKyselyDriver;
+}
+export {};

package/LibSqlDialect.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibSqlDialect = void 0;
+const kysely_1 = require("kysely");
+const CONNECTION_TIMEOUT = 10_000;
+class ConnectionMutex {
+    #promise;
+    #resolve;
+    async lock() {
+        while (this.#promise) {
+            await this.#promise;
+        }
+        this.#promise = new Promise(resolve => {
+            this.#resolve = resolve;
+        });
+    }
+    unlock() {
+        const resolve = this.#resolve;
+        this.#promise = undefined;
+        this.#resolve = undefined;
+        resolve?.();
+    }
+}
+class LibSqlConnection {
+    db;
+    created = Date.now();
+    constructor(db) {
+        this.db = db;
+    }
+    isValid() {
+        return this.memory || this.created > Date.now() - CONNECTION_TIMEOUT;
+    }
+    async executeQuery(compiledQuery) {
+        const { sql, parameters } = compiledQuery;
+        const stmt = this.db.prepare(sql);
+        if (stmt.reader) {
+            return {
+                rows: stmt.all(parameters),
+            };
+        }
+        const query = sql.trim().toLowerCase();
+        /* istanbul ignore next */
+        if (query.startsWith('select') || ((query.startsWith('insert into') || query.startsWith('update ')) && query.includes(' returning '))) {
+            return {
+                rows: stmt.all(parameters),
+            };
+        }
+        const { changes, lastInsertRowid } = stmt.run(parameters);
+        return {
+            numAffectedRows: changes,
+            insertId: lastInsertRowid,
+            rows: [],
+        };
+    }
+    /* istanbul ignore next */
+    async *streamQuery(compiledQuery) {
+        const { sql, parameters } = compiledQuery;
+        const stmt = this.db.prepare(sql);
+        if (!sql.toLowerCase().startsWith('select')) {
+            throw new Error('Sqlite driver only supports streaming of select queries');
+        }
+        for (const row of stmt.iterate(parameters)) {
+            yield {
+                rows: [row],
+            };
+        }
+    }
+}
+class LibSqlKyselyDriver extends kysely_1.SqliteDriver {
+    config;
+    db;
+    connection;
+    connectionMutex = new ConnectionMutex();
+    constructor(config) {
+        super(config);
+        this.config = config;
+    }
+    async init() {
+        this.db = await this.config.database();
+        this.connection = new LibSqlConnection(this.db);
+        /* istanbul ignore next */
+        if (this.config.onCreateConnection) {
+            await this.config.onCreateConnection(this.connection);
+        }
+    }
+    async acquireConnection() {
+        await this.connectionMutex.lock();
+        /* istanbul ignore next */
+        if (!this.connection.isValid()) {
+            await this.destroy();
+            await this.init();
+        }
+        return this.connection;
+    }
+    async releaseConnection() {
+        this.connectionMutex.unlock();
+    }
+    async destroy() {
+        this.db.close();
+    }
+}
+class LibSqlDialect extends kysely_1.SqliteDialect {
+    config;
+    constructor(config) {
+        super(config);
+        this.config = config;
+    }
+    createDriver() {
+        return new LibSqlKyselyDriver(this.config);
+    }
+}
+exports.LibSqlDialect = LibSqlDialect;

package/LibSqlDriver.js

@@ -6,7 +6,7 @@ const LibSqlConnection_1 = require("./LibSqlConnection");
 const LibSqlPlatform_1 = require("./LibSqlPlatform");
 class LibSqlDriver extends knex_1.AbstractSqlDriver {
     constructor(config) {
-        super(config, new LibSqlPlatform_1.LibSqlPlatform(), LibSqlConnection_1.LibSqlConnection, ['knex', 'libsql']);
+        super(config, new LibSqlPlatform_1.LibSqlPlatform(), LibSqlConnection_1.LibSqlConnection, ['kysely', 'libsql']);
     }
 }
 exports.LibSqlDriver = LibSqlDriver;

package/LibSqlPlatform.d.ts

@@ -1,8 +1,4 @@
 import { BaseSqlitePlatform } from '@mikro-orm/knex';
-import { LibSqlSchemaHelper } from './LibSqlSchemaHelper';
-import { LibSqlExceptionConverter } from './LibSqlExceptionConverter';
 export declare class LibSqlPlatform extends BaseSqlitePlatform {
-    protected readonly schemaHelper: LibSqlSchemaHelper;
-    protected readonly exceptionConverter: LibSqlExceptionConverter;
     escape(value: any): string;
 }

package/LibSqlPlatform.js

@@ -4,11 +4,7 @@ exports.LibSqlPlatform = void 0;
 // @ts-ignore
 const sqlstring_sqlite_1 = require("sqlstring-sqlite");
 const knex_1 = require("@mikro-orm/knex");
-const LibSqlSchemaHelper_1 = require("./LibSqlSchemaHelper");
-const LibSqlExceptionConverter_1 = require("./LibSqlExceptionConverter");
 class LibSqlPlatform extends knex_1.BaseSqlitePlatform {
-    schemaHelper = new LibSqlSchemaHelper_1.LibSqlSchemaHelper(this);
-    exceptionConverter = new LibSqlExceptionConverter_1.LibSqlExceptionConverter();
     escape(value) {
         return (0, sqlstring_sqlite_1.escape)(value, true, this.timezone);
     }

package/README.md

@@ -183,7 +183,6 @@ yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
-yarn add @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 
@@ -196,7 +195,6 @@ npm i -s @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 npm i -s @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 npm i -s @mikro-orm/core @mikro-orm/mssql         # for mssql
 npm i -s @mikro-orm/core @mikro-orm/sqlite        # for sqlite
-npm i -s @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
 npm i -s @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 

package/index.d.ts

@@ -2,6 +2,4 @@ export * from '@mikro-orm/knex';
 export * from './LibSqlConnection';
 export * from './LibSqlDriver';
 export * from './LibSqlPlatform';
-export * from './LibSqlSchemaHelper';
-export * from './LibSqlExceptionConverter';
 export { LibSqlMikroORM as MikroORM, LibSqlOptions as Options, defineLibSqlConfig as defineConfig, } from './LibSqlMikroORM';

package/index.js

@@ -20,8 +20,6 @@ __exportStar(require("@mikro-orm/knex"), exports);
 __exportStar(require("./LibSqlConnection"), exports);
 __exportStar(require("./LibSqlDriver"), exports);
 __exportStar(require("./LibSqlPlatform"), exports);
-__exportStar(require("./LibSqlSchemaHelper"), exports);
-__exportStar(require("./LibSqlExceptionConverter"), exports);
 var LibSqlMikroORM_1 = require("./LibSqlMikroORM");
 Object.defineProperty(exports, "MikroORM", { enumerable: true, get: function () { return LibSqlMikroORM_1.LibSqlMikroORM; } });
 Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return LibSqlMikroORM_1.defineLibSqlConfig; } });

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,19 +110,15 @@ 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 Kysely = mod.Kysely;
 export const LibSqlConnection = mod.LibSqlConnection;
 export const LibSqlDriver = mod.LibSqlDriver;
-export const LibSqlExceptionConverter = mod.LibSqlExceptionConverter;
-export const LibSqlKnexDialect = mod.LibSqlKnexDialect;
 export const LibSqlPlatform = mod.LibSqlPlatform;
-export const LibSqlSchemaHelper = mod.LibSqlSchemaHelper;
 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;
@@ -134,13 +128,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;
@@ -160,7 +153,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;
@@ -172,6 +165,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;
@@ -193,8 +187,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;
@@ -228,7 +223,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/libsql",
-  "version": "6.4.7-dev.1",
+  "version": "7.0.0-dev.1",
   "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",
@@ -46,7 +46,7 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 18.12.0"
+    "node": ">= 22.11.0"
   },
   "scripts": {
     "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
@@ -58,15 +58,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/knex": "6.4.7-dev.1",
+    "@mikro-orm/knex": "7.0.0-dev.1",
     "fs-extra": "11.3.0",
     "libsql": "0.4.7",
     "sqlstring-sqlite": "0.1.1"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.6"
+    "@mikro-orm/core": "^6.4.5",
+    "kysely": "https://pkg.pr.new/kysely-org/kysely/kysely@2b7007e"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.4.7-dev.1"
+    "@mikro-orm/core": "7.0.0-dev.1",
+    "kysely": "*"
   }
 }

package/LibSqlExceptionConverter.d.ts

@@ -1,9 +0,0 @@
-import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
-export declare class LibSqlExceptionConverter extends ExceptionConverter {
-    /**
-     * @inheritDoc
-     * @link http://www.sqlite.org/c3ref/c_abort.html
-     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractSQLiteDriver.php
-     */
-    convertException(exception: Error & Dictionary): DriverException;
-}

package/LibSqlExceptionConverter.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LibSqlExceptionConverter = void 0;
-const core_1 = require("@mikro-orm/core");
-class LibSqlExceptionConverter 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.LibSqlExceptionConverter = LibSqlExceptionConverter;

package/LibSqlSchemaHelper.d.ts

@@ -1,3 +0,0 @@
-import { BaseSqliteSchemaHelper } from '@mikro-orm/knex';
-export declare class LibSqlSchemaHelper extends BaseSqliteSchemaHelper {
-}

package/LibSqlSchemaHelper.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LibSqlSchemaHelper = void 0;
-const knex_1 = require("@mikro-orm/knex");
-class LibSqlSchemaHelper extends knex_1.BaseSqliteSchemaHelper {
-}
-exports.LibSqlSchemaHelper = LibSqlSchemaHelper;