@uql/core 3.1.4 → 3.4.0

package/CHANGELOG.md

@@ -3,9 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [3.1.4](https://github.com/rogerpadilla/uql/compare/@uql/core@3.1.3...@uql/core@3.1.4) (2025-12-30)
+# [3.4.0](https://github.com/rogerpadilla/uql/compare/@uql/core@3.3.0...@uql/core@3.4.0) (2025-12-30)
 
-**Note:** Version bump only for package @uql/core
+
+### Features
+
+* add support for Neon, LibSQL, and D1 database queriers, including new querier pools, implementations, tests, and updated documentation. ([aad1df0](https://github.com/rogerpadilla/uql/commit/aad1df0f6bab112b2a0eb0fdffee15dcbc6b0824))
 
 
 
@@ -192,7 +195,7 @@ Reflect major changes in the package structure and dependencies.
 - Update dependencies.
 
   ```ts
-  const ids = await querierPool.transaction(async (querier) => {
+  const ids = await pool.transaction(async (querier) => {
     const data = await querier.findMany(...);
     const ids = await querier.insertMany(...);
     return ids;

package/README.md

@@ -2,13 +2,12 @@
 
 [![uql maku](assets/logo.svg)](https://uql.app)
 
-[![tests](https://github.com/rogerpadilla/uql/actions/workflows/tests.yml/badge.svg)](https://github.com/rogerpadilla/uql) [![coverage status](https://coveralls.io/repos/rogerpadilla/uql/badge.svg?branch=main)](https://coveralls.io/r/rogerpadilla/uql?branch=main) [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/rogerpadilla/uql/blob/main/LICENSE) [![npm version](https://img.shields.io/npm/v/@uql/core.svg)](https://www.npmjs.com/package/@uql/core)
+[![tests](https://github.com/rogerpadilla/uql/actions/workflows/tests.yml/badge.svg)](https://github.com/rogerpadilla/uql) [![Coverage Status](https://coveralls.io/repos/github/rogerpadilla/uql/badge.svg?branch=main)](https://coveralls.io/github/rogerpadilla/uql?branch=main) [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/rogerpadilla/uql/blob/main/LICENSE) [![npm version](https://img.shields.io/npm/v/@uql/core.svg)](https://www.npmjs.com/package/@uql/core)
 
-[UQL](https://uql.app) is the [smartest ORM](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) for TypeScript, it is designed to be fast, safe, and easy to integrate into any application.
+**[UQL](https://uql.app)** is the [smartest ORM](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) for TypeScript. It is engineered to be **fast**, **safe**, and **universally compatible**.
 
-It can run in Node.js, Browser, React Native, Expo, Electron, Deno, Bun, and many more!
-
-Uses a consistent API for distinct databases, including PostgreSQL, MySQL, MariaDB, and SQLite (inspired by MongoDB glorious syntax).
+- **Runs Everywhere**: Node.js, Bun, Deno, Cloudflare Workers, Electron, React Native, and even the Browser.
+- **Unified API**: A consistent, expressive query interface for PostgreSQL, MySQL, MariaDB, SQLite, LibSQL, Neon, Cloudflare D1, and MongoDB (inspired by its glorious syntax).
 
  
 
@@ -33,7 +32,7 @@ See [this article](https://medium.com/@rogerpadillac/in-search-of-the-perfect-or
 
 - **Type-safe and Context-aware queries**: Squeeze the power of `TypeScript` for auto-completion and validation of operators at any depth, [including relations and their fields](https://www.uql.app/docs/querying-relations).
 - **Context-Object SQL Generation**: Uses a sophisticated `QueryContext` pattern to ensure perfectly indexed placeholders ($1, $2, etc.) and robust SQL fragment management, even in the most complex sub-queries.
-- **Unified API across Databases**: Write once, run anywhere. Seamlessly switch between `PostgreSQL`, `MySQL`, `MariaDB`, `SQLite`, and even `MongoDB`.
+- **Unified API across Databases**: Write once, run anywhere. Seamlessly switch between `PostgreSQL`, `MySQL`, `MariaDB`, `SQLite`, `LibSQL`, `Neon`, `Cloudflare D1`, and even `MongoDB`.
 - **Serializable JSON Syntax**: Queries can be expressed as `100%` valid `JSON`, allowing them to be easily transported from frontend to backend.
 - **Naming Strategies**: Effortlessly translate between TypeScript `CamelCase` and database `snake_case` (or any custom format) with a pluggable system.
 - **Built-in Serialization**: A centralized task queue and `@Serialized()` decorator ensure database operations are thread-safe and race-condition free by default.
@@ -56,12 +55,15 @@ See [this article](https://medium.com/@rogerpadillac/in-search-of-the-perfect-or
 
 2. Install one of the specific adapters for your database:
 
-| Database     | Driver
-| ------------ | ----------------
-| `PostgreSQL` | `pg`
-| `SQLite`     | `better-sqlite3`
-| `MariaDB`    | `mariadb`
-| `MySQL`      | `mysql2`
+| Database | Driver
+| :--- | :---
+| `PostgreSQL` (incl. CockroachDB, YugabyteDB) | `pg`
+| `MySQL` (incl. TiDB, Aurora) | `mysql2`
+| `MariaDB` | `mariadb`
+| `SQLite` | `better-sqlite3`
+| `Cloudflare D1` | `Native Binding`
+| `LibSQL` (Turso) | `@libsql/client`
+| `Neon` (Serverless Postgres) | `@neondatabase/serverless`
 
  
 
@@ -92,11 +94,12 @@ bun add pg
 Annotate your classes with decorators from `@uql/core`. UQL supports detailed schema metadata for precise DDL generation.
 
 ```ts
+import { v7 as uuidv7 } from 'uuid';
 import { Entity, Id, Field, OneToOne, OneToMany, ManyToOne, ManyToMany, type Relation } from '@uql/core';
 
 @Entity()
 export class User {
-  @Id()
+  @Id({ onInsert: () => uuidv7() })
   id?: string;
 
   @Field({ length: 100, index: true })
@@ -114,7 +117,7 @@ export class User {
 
 @Entity()
 export class Profile {
-  @Id()
+  @Id({ onInsert: () => uuidv7() })
   id?: string;
 
   @Field()
@@ -147,7 +150,7 @@ export class Post {
 
 @Entity()
 export class Tag {
-  @Id()
+  @Id({ onInsert: () => uuidv7() })
   id?: string;
 
   @Field()
@@ -156,7 +159,7 @@ export class Tag {
 
 @Entity()
 export class PostTag {
-  @Id()
+  @Id({ onInsert: () => uuidv7() })
   id?: string;
 
   @Field({ reference: () => Post })
@@ -178,7 +181,7 @@ A querier-pool can be set in any of the bootstrap files of your app (e.g. in the
 import { SnakeCaseNamingStrategy } from '@uql/core';
 import { PgQuerierPool } from '@uql/core/postgres';
 
-export const querierPool = new PgQuerierPool(
+export const pool = new PgQuerierPool(
   {
     host: 'localhost',
     user: 'theUser',
@@ -211,10 +214,10 @@ Repositories provide a clean, Data-Mapper style interface for your entities.
 ```ts
 import { GenericRepository } from '@uql/core';
 import { User } from './shared/models/index.js';
-import { querierPool } from './shared/orm.js';
+import { pool } from './shared/orm.js';
 
 // Get a querier from the pool
-const querier = await querierPool.getQuerier();
+const querier = await pool.getQuerier();
 
 try {
   const userRepository = new GenericRepository(User, querier);
@@ -246,10 +249,10 @@ UQL's query syntax is context-aware. When you query a relation, the available fi
 
 ```ts
 import { GenericRepository } from '@uql/core';
-import { querierPool } from './shared/orm.js';
+import { pool } from './shared/orm.js';
 import { User } from './shared/models/index.js';
 
-const authorsWithPopularPosts = await querierPool.transaction(async (querier) => {
+const authorsWithPopularPosts = await pool.transaction(async (querier) => {
   const userRepository = new GenericRepository(User, querier);
 
   return userRepository.findMany({
@@ -282,6 +285,7 @@ const authorsWithPopularPosts = await querierPool.transaction(async (querier) =>
 Define complex logic directly in your entities using `raw` functions from `uql/util`. These are highly efficient as they are resolved during SQL generation.
 
 ```ts
+import { v7 as uuidv7 } from 'uuid';
 import { Entity, Id, Field, raw } from '@uql/core';
 import { ItemTag } from './shared/models/index.js';
 
@@ -313,10 +317,10 @@ export class Item {
 UQL ensures your operations are serialized and thread-safe.
 
 ```ts
-import { querierPool } from './shared/orm.js';
+import { pool } from './shared/orm.js';
 import { User, Profile } from './shared/models/index.js';
 
-const result = await querierPool.transaction(async (querier) => {
+const result = await pool.transaction(async (querier) => {
   const user = await querier.findOne(User, { $where: { email: '...' } });
   const profileId = await querier.insertOne(Profile, { userId: user.id, ... });
   return { userId: user.id, profileId };
@@ -339,7 +343,7 @@ import { PgQuerierPool } from '@uql/core/postgres';
 import { User, Post } from './shared/models/index.js';
 
 export default {
-  querierPool: new PgQuerierPool({ /* config */ }),
+  pool: new PgQuerierPool({ /* config */ }),
   entities: [User, Post],
   migrationsPath: './migrations',
 };
@@ -377,9 +381,9 @@ In development, you can use `autoSync` to automatically keep your database in sy
 
 ```ts
 import { Migrator } from '@uql/core/migrate';
-import { querierPool } from './shared/orm.js';
+import { pool } from './shared/orm.js';
 
-const migrator = new Migrator(querierPool);
+const migrator = new Migrator(pool);
 await migrator.autoSync({ logging: true });
 ```
 
@@ -406,3 +410,13 @@ For those who want to see the "engine under the hood," check out these resources
   - [PostgreSQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/postgres/postgresDialect.spec.ts) | [MySQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/mysql/mysqlDialect.spec.ts) | [SQLite Spec](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/sqlite/sqliteDialect.spec.ts).
   - [Querier Integration Tests](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/querier/abstractSqlQuerier-spec.ts): Testing the interaction between SQL generation and connection management.
   - [MongoDB Migration Tests](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/migrate/migrator-mongo.it.ts): Integration tests ensuring correct collection and index synchronization for MongoDB.
+
+---
+
+## Built with ❤️ and supported by
+
+UQL is an open-source project driven by the community and proudly sponsored by **[Variability.ai](https://variability.ai)**.
+
+> "Intelligence in Every Fluctuation"
+
+Their support helps us maintain and evolve the "Smartest ORM" for developers everywhere. Thank you for being part of our journey!

package/dist/browser/uql-browser.min.js

@@ -1,108 +1,97 @@
-import sqlstring from 'sqlstring-sqlite';
-import { AbstractSqlDialect } from '../dialect/index.js';
-import { getMeta } from '../entity/index.js';
-import { AbstractSqlQuerier, AbstractQuerierPool } from '../querier/index.js';
+import { isSqlQuerier } from '../type/index.js';
+export { isSqlQuerier } from '../type/index.js';
+import { AbstractDialect } from '../dialect/index.js';
+import { getMeta, getEntities } from '../entity/index.js';
+import { escapeSqlId, getKeys } from '../util/index.js';
+import { readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
+import { join, basename, extname, dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
 
-class SqliteDialect extends AbstractSqlDialect {
-    constructor(namingStrategy){
-        super(namingStrategy, '`', 'BEGIN TRANSACTION');
-    }
-    addValue(values, value) {
-        if (value instanceof Date) {
-            value = value.getTime();
-        } else if (typeof value === 'boolean') {
-            value = value ? 1 : 0;
-        }
-        return super.addValue(values, value);
-    }
-    compare(ctx, entity, key, val, opts) {
-        if (key === '$text') {
-            const meta = getMeta(entity);
-            const search = val;
-            const fields = search.$fields.map((fKey)=>{
-                const field = meta.fields[fKey];
-                const columnName = this.resolveColumnName(fKey, field);
-                return this.escapeId(columnName);
-            });
-            const tableName = this.resolveTableName(entity, meta);
-            ctx.append(`${this.escapeId(tableName)} MATCH {${fields.join(' ')}} : `);
-            ctx.addValue(search.$value);
-            return;
-        }
-        super.compare(ctx, entity, key, val, opts);
+/**
+ * Abstract base class for SQL schema generation
+ */ class AbstractSchemaGenerator extends AbstractDialect {
+    constructor(namingStrategy, escapeIdChar = '`'){
+        super(namingStrategy), this.escapeIdChar = escapeIdChar;
     }
-    compareFieldOperator(ctx, entity, key, op, val, opts = {}) {
-        super.compareFieldOperator(ctx, entity, key, op, val, opts);
+    /**
+   * Escape an identifier (table name, column name, etc.)
+   */ escapeId(identifier) {
+        return escapeSqlId(identifier, this.escapeIdChar);
     }
-    upsert(ctx, entity, conflictPaths, payload) {
+    generateCreateTable(entity, options = {}) {
         const meta = getMeta(entity);
-        const update = this.getUpsertUpdateAssignments(ctx, meta, conflictPaths, payload, (name)=>`EXCLUDED.${name}`);
-        const keysStr = this.getUpsertConflictPathsStr(meta, conflictPaths);
-        const onConflict = update ? `DO UPDATE SET ${update}` : 'DO NOTHING';
-        this.insert(ctx, entity, payload);
-        ctx.append(` ON CONFLICT (${keysStr}) ${onConflict}`);
-    }
-    escape(value) {
-        return sqlstring.escape(value);
+        const tableName = this.resolveTableName(entity, meta);
+        const columns = this.generateColumnDefinitions(meta);
+        const constraints = this.generateTableConstraints(meta);
+        const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';
+        let sql = `CREATE TABLE ${ifNotExists}${this.escapeId(tableName)} (\n`;
+        sql += columns.map((col)=>`  ${col}`).join(',\n');
+        if (constraints.length > 0) {
+            sql += ',\n';
+            sql += constraints.map((c)=>`  ${c}`).join(',\n');
+        }
+        sql += '\n)';
+        sql += this.getTableOptions(meta);
+        sql += ';';
+        return sql;
     }
-}
-
-class SqliteQuerier extends AbstractSqlQuerier {
-    constructor(db, extra){
-        super(new SqliteDialect(extra?.namingStrategy)), this.db = db, this.extra = extra;
-    }
-    async internalAll(query, values) {
-        this.extra?.logger?.(query, values);
-        return this.db.prepare(query).all(values || []);
-    }
-    async internalRun(query, values) {
-        this.extra?.logger?.(query, values);
-        const { changes, lastInsertRowid } = this.db.prepare(query).run(values || []);
-        const firstId = lastInsertRowid ? Number(lastInsertRowid) - (changes - 1) : undefined;
-        const ids = firstId ? Array(changes).fill(firstId).map((i, index)=>i + index) : [];
-        return {
-            changes,
-            ids,
-            firstId
-        };
+    generateDropTable(entity) {
+        const meta = getMeta(entity);
+        const tableName = this.resolveTableName(entity, meta);
+        return `DROP TABLE IF EXISTS ${this.escapeId(tableName)};`;
     }
-    async internalRelease() {
-        if (this.hasOpenTransaction) {
-            throw TypeError('pending transaction');
+    generateAlterTable(diff) {
+        const statements = [];
+        const tableName = this.escapeId(diff.tableName);
+        // Add new columns
+        if (diff.columnsToAdd?.length) {
+            for (const column of diff.columnsToAdd){
+                const colDef = this.generateColumnDefinitionFromSchema(column);
+                statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${colDef};`);
+            }
         }
-    // no-op
-    }
-}
-
-class Sqlite3QuerierPool extends AbstractQuerierPool {
-    constructor(filename, opts, extra){
-        super('sqlite', extra), this.filename = filename, this.opts = opts;
-    }
-    async getQuerier() {
-        if (!this.querier) {
-            let db;
-            if (typeof Bun !== 'undefined') {
-                const { Database } = await import('bun:sqlite');
-                db = new Database(this.filename, this.opts);
-                db.run('PRAGMA journal_mode = WAL');
-            } else {
-                const { default: Database } = await import('better-sqlite3');
-                db = new Database(this.filename, this.opts);
-                db.pragma('journal_mode = WAL');
+        // Alter existing columns
+        if (diff.columnsToAlter?.length) {
+            for (const { to } of diff.columnsToAlter){
+                const colDef = this.generateColumnDefinitionFromSchema(to);
+                const colStatements = this.generateAlterColumnStatements(diff.tableName, to, colDef);
+                statements.push(...colStatements);
+            }
+        }
+        // Drop columns
+        if (diff.columnsToDrop?.length) {
+            for (const columnName of diff.columnsToDrop){
+                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(columnName)};`);
             }
-            this.querier = new SqliteQuerier(db, this.extra);
         }
-        return this.querier;
+        // Add indexes
+        if (diff.indexesToAdd?.length) {
+            for (const index of diff.indexesToAdd){
+                statements.push(this.generateCreateIndex(diff.tableName, index));
+            }
+        }
+        // Drop indexes
+        if (diff.indexesToDrop?.length) {
+            for (const indexName of diff.indexesToDrop){
+                statements.push(this.generateDropIndex(diff.tableName, indexName));
+            }
+        }
+        return statements;
     }
-    async end() {
-        await this.querier.db.close();
-        delete this.querier;
+    generateAlterTableDown(diff) {
+        const statements = [];
+        const tableName = this.escapeId(diff.tableName);
+        // Rollback additions by dropping columns
+        if (diff.columnsToAdd?.length) {
+            for (const column of diff.columnsToAdd){
+                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(column.name)};`);
+            }
+        }
+        return statements;
     }
-}
-
-export { Sqlite3QuerierPool, SqliteDialect, SqliteQuerier };
-//# sourceMappingURL=uql-browser.min.js.map
->this.escapeId(c)).join(', ');
+    generateCreateIndex(tableName, index) {
+        const unique = index.unique ? 'UNIQUE ' : '';
+        const columns = index.columns.map((c)=>this.escapeId(c)).join(', ');
         return `CREATE ${unique}INDEX ${this.escapeId(index.name)} ON ${this.escapeId(tableName)} (${columns});`;
     }
     generateDropIndex(tableName, indexName) {
@@ -620,8 +609,8 @@ export { Sqlite3QuerierPool, SqliteDialect, SqliteQuerier };
  * MySQL/MariaDB schema introspector.
  * Works with both MySQL and MariaDB as they share the same information_schema structure.
  */ class MysqlSchemaIntrospector {
-    constructor(querierPool){
-        this.querierPool = querierPool;
+    constructor(pool){
+        this.pool = pool;
     }
     async getTableSchema(tableName) {
         const querier = await this.getQuerier();
@@ -684,7 +673,7 @@ export { Sqlite3QuerierPool, SqliteDialect, SqliteQuerier };
         return (results[0]?.count ?? 0) > 0;
     }
     async getQuerier() {
-        const querier = await this.querierPool.getQuerier();
+        const querier = await this.pool.getQuerier();
         if (!isSqlQuerier(querier)) {
             await querier.release();
             throw new Error('MysqlSchemaIntrospector requires a SQL-based querier');
@@ -842,8 +831,8 @@ export { Sqlite3QuerierPool, SqliteDialect, SqliteQuerier };
 /**
  * PostgreSQL schema introspector
  */ class PostgresSchemaIntrospector {
-    constructor(querierPool){
-        this.querierPool = querierPool;
+    constructor(pool){
+        this.pool = pool;
     }
     async getTableSchema(tableName) {
         const querier = await this.getQuerier();
@@ -907,7 +896,7 @@ export { Sqlite3QuerierPool, SqliteDialect, SqliteQuerier };
         return results[0]?.exists ?? false;
     }
     async getQuerier() {
-        const querier = await this.querierPool.getQuerier();
+        const querier = await this.pool.getQuerier();
         if (!isSqlQuerier(querier)) {
             await querier.release();
             throw new Error('PostgresSchemaIntrospector requires a SQL-based querier');
@@ -1115,8 +1104,8 @@ export { Sqlite3QuerierPool, SqliteDialect, SqliteQuerier };
 /**
  * SQLite schema introspector
  */ class SqliteSchemaIntrospector {
-    constructor(querierPool){
-        this.querierPool = querierPool;
+    constructor(pool){
+        this.pool = pool;
     }
     async getTableSchema(tableName) {
         const querier = await this.getQuerier();
@@ -1179,7 +1168,7 @@ export { Sqlite3QuerierPool, SqliteDialect, SqliteQuerier };
         return (results[0]?.count ?? 0) > 0;
     }
     async getQuerier() {
-        const querier = await this.querierPool.getQuerier();
+        const querier = await this.pool.getQuerier();
         if (!isSqlQuerier(querier)) {
             await querier.release();
             throw new Error('SqliteSchemaIntrospector requires a SQL-based querier');
@@ -1436,11 +1425,11 @@ class MongoSchemaGenerator extends AbstractDialect {
 }
 
 class MongoSchemaIntrospector {
-    constructor(querierPool){
-        this.querierPool = querierPool;
+    constructor(pool){
+        this.pool = pool;
     }
     async getTableSchema(tableName) {
-        const querier = await this.querierPool.getQuerier();
+        const querier = await this.pool.getQuerier();
         try {
             const { db } = querier;
             const collections = await db.listCollections({
@@ -1465,7 +1454,7 @@ class MongoSchemaIntrospector {
         }
     }
     async getTableNames() {
-        const querier = await this.querierPool.getQuerier();
+        const querier = await this.pool.getQuerier();
         try {
             const { db } = querier;
             const collections = await db.listCollections().toArray();
@@ -1484,8 +1473,8 @@ class MongoSchemaIntrospector {
  * Stores migration state in a database table.
  * Uses the querier's dialect for escaping and placeholders.
  */ class DatabaseMigrationStorage {
-    constructor(querierPool, options = {}){
-        this.querierPool = querierPool;
+    constructor(pool, options = {}){
+        this.pool = pool;
         this.storageInitialized = false;
         this.tableName = options.tableName ?? 'uql_migrations';
     }
@@ -1493,7 +1482,7 @@ class MongoSchemaIntrospector {
         if (this.storageInitialized) {
             return;
         }
-        const querier = await this.querierPool.getQuerier();
+        const querier = await this.pool.getQuerier();
         if (!isSqlQuerier(querier)) {
             await querier.release();
             throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
@@ -1517,7 +1506,7 @@ class MongoSchemaIntrospector {
     }
     async executed() {
         await this.ensureStorage();
-        const querier = await this.querierPool.getQuerier();
+        const querier = await this.pool.getQuerier();
         if (!isSqlQuerier(querier)) {
             await querier.release();
             throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
@@ -1556,10 +1545,10 @@ class MongoSchemaIntrospector {
 /**
  * Main class for managing database migrations
  */ class Migrator {
-    constructor(querierPool, options = {}){
-        this.querierPool = querierPool;
-        this.dialect = options.dialect ?? querierPool.dialect ?? 'postgres';
-        this.storage = options.storage ?? new DatabaseMigrationStorage(querierPool, {
+    constructor(pool, options = {}){
+        this.pool = pool;
+        this.dialect = options.dialect ?? pool.dialect ?? 'postgres';
+        this.storage = options.storage ?? new DatabaseMigrationStorage(pool, {
             tableName: options.tableName
         });
         this.migrationsPath = options.migrationsPath ?? './migrations';
@@ -1576,15 +1565,15 @@ class MongoSchemaIntrospector {
     createIntrospector() {
         switch(this.dialect){
             case 'postgres':
-                return new PostgresSchemaIntrospector(this.querierPool);
+                return new PostgresSchemaIntrospector(this.pool);
             case 'mysql':
-                return new MysqlSchemaIntrospector(this.querierPool);
+                return new MysqlSchemaIntrospector(this.pool);
             case 'mariadb':
-                return new MariadbSchemaIntrospector(this.querierPool);
+                return new MariadbSchemaIntrospector(this.pool);
             case 'sqlite':
-                return new SqliteSchemaIntrospector(this.querierPool);
+                return new SqliteSchemaIntrospector(this.pool);
             case 'mongodb':
-                return new MongoSchemaIntrospector(this.querierPool);
+                return new MongoSchemaIntrospector(this.pool);
             default:
                 return undefined;
         }
@@ -1698,7 +1687,7 @@ class MongoSchemaIntrospector {
    * Run a single migration within a transaction
    */ async runMigration(migration, direction) {
         const startTime = Date.now();
-        const querier = await this.querierPool.getQuerier();
+        const querier = await this.pool.getQuerier();
         if (!isSqlQuerier(querier)) {
             await querier.release();
             throw new Error('Migrator requires a SQL-based querier');
@@ -1840,7 +1829,7 @@ class MongoSchemaIntrospector {
             throw new Error('Schema generator not set. Call setSchemaGenerator() first.');
         }
         const entities = this.entities.length > 0 ? this.entities : getEntities();
-        const querier = await this.querierPool.getQuerier();
+        const querier = await this.pool.getQuerier();
         if (!isSqlQuerier(querier)) {
             await querier.release();
             throw new Error('Migrator requires a SQL-based querier');
@@ -1912,7 +1901,7 @@ class MongoSchemaIntrospector {
         return filteredDiff;
     }
     async executeSyncStatements(statements, options) {
-        const querier = await this.querierPool.getQuerier();
+        const querier = await this.pool.getQuerier();
         try {
             if (this.dialect === 'mongodb') {
                 await this.executeMongoSyncStatements(statements, options, querier);