@stingerloom/orm 0.2.0 → 0.3.0

package/dist/core/EntityManager.js

@@ -32,46 +32,43 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityManager = void 0;
 require("reflect-metadata");
 const utils_1 = require("../utils");
-const scanner_1 = require("../scanner");
-const typedi_1 = __importDefault(require("typedi"));
 const DatabaseClient_1 = require("../DatabaseClient");
 const MySqlDriver_1 = require("../dialects/mysql/MySqlDriver");
 const PostgresDriver_1 = require("../dialects/postgres/PostgresDriver");
 const SqliteDriver_1 = require("../dialects/sqlite/SqliteDriver");
-const SchemaGenerator_1 = require("./generators/SchemaGenerator");
-const Indexer_1 = require("../decorators/Indexer");
-const UniqueIndex_1 = require("../decorators/UniqueIndex");
 const TransactionSessionManager_1 = require("../dialects/TransactionSessionManager");
 const MySqlDataSource_1 = require("../dialects/mysql/MySqlDataSource");
 const PostgresDataSource_1 = require("../dialects/postgres/PostgresDataSource");
 const SqliteDataSource_1 = require("../dialects/sqlite/SqliteDataSource");
 const sql_template_tag_1 = __importStar(require("sql-template-tag"));
-const decorators_1 = require("../decorators");
 const BaseRepository_1 = require("./BaseRepository");
-const EntityNotFound_1 = require("../dialects/EntityNotFound");
 const RawQueryBuilderFactory_1 = require("./RawQueryBuilderFactory");
 const Conditions_1 = require("./Conditions");
 const ResultTransformerFactory_1 = require("./ResultTransformerFactory");
 const MetadataContext_1 = require("../metadata/MetadataContext");
 const LazyLoader_1 = require("./LazyLoader");
-const CascadeType_1 = require("../types/CascadeType");
 const EntityValidator_1 = require("./EntityValidator");
 const EntityEventEmitter_1 = require("./EntityEventEmitter");
 const EntityMetadataNotFoundError_1 = require("../errors/EntityMetadataNotFoundError");
 const InvalidQueryError_1 = require("../errors/InvalidQueryError");
+const OptimisticLockError_1 = require("../errors/OptimisticLockError");
 const PrimaryKeyNotFoundError_1 = require("../errors/PrimaryKeyNotFoundError");
 const DeleteWithoutConditionsError_1 = require("../errors/DeleteWithoutConditionsError");
 const NotSupportedDatabaseTypeError_1 = require("../errors/NotSupportedDatabaseTypeError");
 const QueryTracker_1 = require("./QueryTracker");
 const CursorPagination_1 = require("./CursorPagination");
-const ReplicationRouter_1 = require("../dialects/ReplicationRouter");
+const Transactional_1 = require("../decorators/Transactional");
+const RelationMetadataResolver_1 = require("./RelationMetadataResolver");
+const ReplicationManager_1 = require("./ReplicationManager");
+const CascadeHandler_1 = require("./CascadeHandler");
+const RelationLoader_1 = require("./RelationLoader");
+const SchemaRegistrar_1 = require("./SchemaRegistrar");
+const ExplainQueryHandler_1 = require("./ExplainQueryHandler");
+const AggregateQueryHandler_1 = require("./AggregateQueryHandler");
 class EntityManager {
     constructor() {
         this._entities = [];
@@ -79,13 +76,39 @@ class EntityManager {
         this.dirtyEntities = new Set();
         this.eventEmitter = new EntityEventEmitter_1.EntityEventEmitter();
         this.subscribers = [];
+        this.cursorPkWarned = new Set();
         this.queryTracker = null;
-        this.replicationRouter = null;
         this.connectionName = "default";
+        this.resolver = new RelationMetadataResolver_1.RelationMetadataResolver();
+        this.replication = new ReplicationManager_1.ReplicationManager();
+        this._ctx = {
+            wrap: (col) => this.wrap(col),
+            isMySqlFamily: () => this.isMySqlFamily(),
+            isPostgres: () => this.isPostgres(),
+            getDriver: () => this.driver,
+            getSynchronize: () => this.client.getOptions().synchronize ?? false,
+            executeInTransaction: (fn, s, r) => this.executeInTransaction(fn, s, r),
+            beginTrackQuery: () => this.beginTrackQuery(),
+            trackQuery: (e, s, m) => this.trackQuery(e, s, m),
+            getReadNode: (u) => this.getReadNode(u),
+            getNameStrategy: (c) => this.getNameStrategy(c),
+            resolveSelectColumns: (s) => this.resolveSelectColumns(s),
+            markDirty: (e) => this.dirtyEntities.add(e),
+            findInternal: (e, o, s) => this.findInternal(e, o, s),
+            findOneInternal: (e, o, s) => this.findOneInternal(e, o, s),
+            save: (e, i) => this.save(e, i),
+            find: (e, o) => this.find(e, o),
+            delete: (e, c) => this.delete(e, c),
+        };
+        this.cascadeHandler = new CascadeHandler_1.CascadeHandler(this.resolver, this._ctx);
+        this.relationLoader = new RelationLoader_1.RelationLoader(this.resolver, this._ctx);
+        this.schemaRegistrar = new SchemaRegistrar_1.SchemaRegistrar(this.resolver, this._ctx);
+        this.explainHandler = new ExplainQueryHandler_1.ExplainQueryHandler(this.resolver, this._ctx);
+        this.aggregateHandler = new AggregateQueryHandler_1.AggregateQueryHandler(this.resolver, this._ctx);
     }
     async register(databaseClientOptions, connectionName = "default") {
         await this.connect(databaseClientOptions, connectionName);
-        await this.registerEntities();
+        await this.schemaRegistrar.registerEntities();
     }
     get client() {
         return DatabaseClient_1.DatabaseClient.getInstance();
@@ -132,9 +155,43 @@ class EntityManager {
             this.defaultQueryTimeout = queryTimeout;
         }
         if (replication) {
-            this.replicationRouter = new ReplicationRouter_1.ReplicationRouter(replication);
+            this.replication.initialize(replication);
         }
     }
+    async propagateShutdown(options) {
+        const gracefulTimeoutMs = options?.gracefulTimeoutMs ?? 0;
+        const closeConnections = options?.closeConnections ?? false;
+        let allQueriesCompleted = true;
+        if (gracefulTimeoutMs > 0 && this.queryTracker) {
+            const activeCount = this.queryTracker.activeQueryCount;
+            if (activeCount > 0) {
+                this.logger.info(`[Shutdown] Waiting for ${activeCount} active queries (timeout: ${gracefulTimeoutMs}ms)...`);
+                allQueriesCompleted = await this.queryTracker.waitForQueries(gracefulTimeoutMs);
+                if (!allQueriesCompleted) {
+                    this.logger.warn(`[Shutdown] Timed out waiting for active queries. Forcing shutdown.`);
+                }
+            }
+        }
+        this.removeAllListeners();
+        this.subscribers.length = 0;
+        this.dirtyEntities.clear();
+        this.cursorPkWarned.clear();
+        this.queryTracker?.reset();
+        this.queryTracker = null;
+        this.replication.shutdown();
+        if (closeConnections) {
+            try {
+                await this.client.close(this.connectionName);
+            }
+            catch (err) {
+                this.logger.warn(`[Shutdown] Error closing connection '${this.connectionName}': ${err}`);
+            }
+        }
+        return allQueriesCompleted;
+    }
+    getNameStrategy(clazz) {
+        return clazz.name;
+    }
     initQueryTracker(options) {
         const logging = options.logging;
         if (typeof logging === "object" && logging !== null) {
@@ -167,22 +224,16 @@ class EntityManager {
         this.queryTracker?.track(entityName, sqlText, durationMs);
     }
     getReadNode(useMaster) {
-        if (!this.replicationRouter)
-            return null;
-        if (useMaster)
-            return this.replicationRouter.getWriteNode();
-        return this.replicationRouter.getReadNode();
+        return this.replication.getReadNode(useMaster);
     }
     getWriteNode() {
-        if (!this.replicationRouter)
-            return null;
-        return this.replicationRouter.getWriteNode();
+        return this.replication.getWriteNode();
     }
     get isReplicationEnabled() {
-        return this.replicationRouter !== null;
+        return this.replication.isEnabled;
     }
     getReplicationRouter() {
-        return this.replicationRouter;
+        return this.replication.getRouter();
     }
     on(event, listener) {
         this.eventEmitter.on(event, listener);
@@ -216,606 +267,11 @@ class EntityManager {
             }
         }
     }
-    async propagateShutdown(options) {
-        const gracefulTimeoutMs = options?.gracefulTimeoutMs ?? 0;
-        const closeConnections = options?.closeConnections ?? false;
-        let allQueriesCompleted = true;
-        if (gracefulTimeoutMs > 0 && this.queryTracker) {
-            const activeCount = this.queryTracker.activeQueryCount;
-            if (activeCount > 0) {
-                this.logger.info(`[Shutdown] Waiting for ${activeCount} active queries (timeout: ${gracefulTimeoutMs}ms)...`);
-                allQueriesCompleted = await this.queryTracker.waitForQueries(gracefulTimeoutMs);
-                if (!allQueriesCompleted) {
-                    this.logger.warn(`[Shutdown] Timed out waiting for active queries. Forcing shutdown.`);
-                }
-            }
-        }
-        this.removeAllListeners();
-        this.subscribers.length = 0;
-        this.dirtyEntities.clear();
-        this.queryTracker?.reset();
-        this.queryTracker = null;
-        if (this.replicationRouter) {
-            this.replicationRouter.resetFailedSlaves();
-            this.replicationRouter = null;
-        }
-        if (closeConnections) {
-            try {
-                await this.client.close(this.connectionName);
-            }
-            catch (err) {
-                this.logger.warn(`[Shutdown] Error closing connection '${this.connectionName}': ${err}`);
-            }
-        }
-        return allQueriesCompleted;
-    }
-    getNameStrategy(clazz) {
-        return clazz.name;
-    }
-    resolveEntityMetadata(entity) {
-        const context = MetadataContext_1.MetadataContext.isActive()
-            ? MetadataContext_1.MetadataContext.getCurrentTenant()
-            : "public";
-        const entityScanner = typedi_1.default.get(scanner_1.EntityScanner);
-        const layeredMetadata = entityScanner.scan(entity);
-        if (layeredMetadata) {
-            return layeredMetadata;
-        }
-        const reflectMetadata = Reflect.getMetadata(decorators_1.ENTITY_TOKEN, entity);
-        if (reflectMetadata) {
-            this.logger.warn(`[resolveEntityMetadata] "${entity.name}" resolved via Reflect.getMetadata fallback (context: "${context}"). ` +
-                `This entity was not found in the layered store.`);
-        }
-        else {
-            this.logger.error(`[resolveEntityMetadata] "${entity.name}" not found in any metadata source (context: "${context}")`);
-        }
-        return reflectMetadata ?? null;
-    }
-    getDeletedAtColumn(entity) {
-        const column = Reflect.getMetadata(decorators_1.DELETED_AT_TOKEN, entity);
-        return column ?? null;
-    }
-    async runHooks(entity, item, event) {
-        const hooks = Reflect.getMetadata(decorators_1.HOOK_TOKEN, entity);
-        if (!hooks || hooks.length === 0)
-            return;
-        for (const hook of hooks) {
-            if (hook.event !== event)
-                continue;
-            const method = item[hook.methodName];
-            if (typeof method === "function") {
-                await method.call(item);
-            }
-        }
-    }
-    createProxy(entity) {
-        return new Proxy(entity, {
-            set: (target, prop, value) => {
-                target[prop] = value;
-                this.dirtyEntities.add(target);
-                return true;
-            },
-        });
-    }
-    async registerEntities() {
-        const entityScanner = typedi_1.default.get(scanner_1.EntityScanner);
-        const entities = entityScanner.makeEntities();
-        let entity;
-        const { synchronize } = this.client.getOptions();
-        if (synchronize && this.isPostgres() && this.driver) {
-            const pgDriver = this.driver;
-            const hasSchema = await pgDriver.hasSchema();
-            if (!hasSchema || hasSchema.length === 0) {
-                await pgDriver.createSchema();
-                await pgDriver.setSearchPath();
-            }
-        }
-        const entityList = [];
-        while ((entity = entities.next())) {
-            if (entity.done) {
-                break;
-            }
-            const metadata = entity.value;
-            const TargetEntity = metadata.target;
-            let tableName = metadata.name;
-            if (!tableName) {
-                tableName = this.getNameStrategy(TargetEntity);
-            }
-            if (!utils_1.ReflectManager.isEntity(TargetEntity)) {
-                throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(tableName ?? "Unknown");
-            }
-            if (synchronize) {
-                const hasTable = await this.driver?.hasTable(tableName);
-                if (!hasTable || hasTable.length === 0) {
-                    await this.driver?.createTable(tableName, metadata.columns);
-                }
-            }
-            entityList.push({ TargetEntity, tableName, metadata });
-        }
-        if (synchronize) {
-            for (const { TargetEntity, tableName } of entityList) {
-                await this.registerForeignKeys(TargetEntity, tableName);
-                await this.registerIndex(TargetEntity, tableName);
-                await this.registerUniqueIndexes(TargetEntity, tableName);
-            }
-            await this.registerManyToManyJoinTables(entityList.map((e) => e.TargetEntity));
-        }
-    }
-    async registerUniqueIndexes(TargetEntity, tableName) {
-        const uniqueIndexes = Reflect.getMetadata(UniqueIndex_1.UNIQUE_INDEX_TOKEN, TargetEntity);
-        if (!uniqueIndexes || uniqueIndexes.length === 0)
-            return;
-        for (const uq of uniqueIndexes) {
-            const indexName = uq.name ?? `uq_${tableName}_${uq.columns.join("_")}`;
-            const indexes = (await this.driver?.getIndexes(tableName));
-            let isExist = false;
-            for (const idx of indexes || []) {
-                const existingIndexName = idx["Key_name"] ?? idx["Field"] ?? idx["name"];
-                if (existingIndexName === indexName) {
-                    isExist = true;
-                    break;
-                }
-            }
-            if (!isExist) {
-                await this.driver?.addCompositeUniqueIndex(tableName, uq.columns, indexName);
-            }
-        }
-    }
-    async registerManyToManyJoinTables(entities) {
-        const processedTables = new Set();
-        for (const entity of entities) {
-            const m2mMeta = (Reflect.getMetadata(decorators_1.MANY_TO_MANY_TOKEN, entity) ??
-                []);
-            for (const rel of m2mMeta) {
-                if (!rel.joinTable)
-                    continue;
-                const { name: joinTableName, joinColumn, inverseJoinColumn, } = rel.joinTable;
-                if (processedTables.has(joinTableName))
-                    continue;
-                processedTables.add(joinTableName);
-                const ownerEntityMeta = Reflect.getMetadata(decorators_1.ENTITY_TOKEN, entity);
-                const ownerTable = ownerEntityMeta?.name ?? entity.name;
-                const relatedEntity = rel.getRelatedEntity();
-                const relatedEntityMeta = Reflect.getMetadata(decorators_1.ENTITY_TOKEN, relatedEntity);
-                const relatedTable = relatedEntityMeta?.name ?? relatedEntity.name;
-                const hasTable = await this.driver?.hasTable(joinTableName);
-                if (!hasTable || hasTable.length === 0) {
-                    const wJoinTable = this.wrap(joinTableName);
-                    const wJoinCol = this.wrap(joinColumn);
-                    const wInvCol = this.wrap(inverseJoinColumn);
-                    let ddl = `CREATE TABLE IF NOT EXISTS ${wJoinTable} (${wJoinCol} INT NOT NULL, ${wInvCol} INT NOT NULL, PRIMARY KEY (${wJoinCol}, ${wInvCol}))`;
-                    if (this.isMySqlFamily())
-                        ddl += " ENGINE=InnoDB";
-                    await this.driver?.executeRaw(ddl);
-                }
-                const ownerColumns = (Reflect.getMetadata(decorators_1.COLUMN_TOKEN, entity.prototype) ?? []);
-                const ownerPk = ownerColumns.find((c) => c.options?.primary)?.name;
-                const relatedColumns = (Reflect.getMetadata(decorators_1.COLUMN_TOKEN, relatedEntity.prototype) ?? []);
-                const relatedPk = relatedColumns.find((c) => c.options?.primary)?.name;
-                const ownerFkName = SchemaGenerator_1.SchemaGenerator.generateForeignKeyName(joinTableName, joinColumn, ownerTable);
-                if (ownerPk &&
-                    this.driver &&
-                    !(await this.driver.hasForeignKey(joinTableName, ownerFkName))) {
-                    const ddl = `ALTER TABLE ${this.wrap(joinTableName)} ADD CONSTRAINT ${ownerFkName} FOREIGN KEY (${this.wrap(joinColumn)}) REFERENCES ${this.wrap(ownerTable)}(${this.wrap(ownerPk)}) ON DELETE CASCADE ON UPDATE CASCADE`;
-                    await this.driver.executeRaw(ddl);
-                }
-                const relatedFkName = SchemaGenerator_1.SchemaGenerator.generateForeignKeyName(joinTableName, inverseJoinColumn, relatedTable);
-                if (relatedPk &&
-                    this.driver &&
-                    !(await this.driver.hasForeignKey(joinTableName, relatedFkName))) {
-                    const ddl = `ALTER TABLE ${this.wrap(joinTableName)} ADD CONSTRAINT ${relatedFkName} FOREIGN KEY (${this.wrap(inverseJoinColumn)}) REFERENCES ${this.wrap(relatedTable)}(${this.wrap(relatedPk)}) ON DELETE CASCADE ON UPDATE CASCADE`;
-                    await this.driver.executeRaw(ddl);
-                }
-            }
-        }
-    }
-    resolveManyToOneMetadata(entity) {
-        const manyToOneScanner = typedi_1.default.get(scanner_1.ManyToOneScanner);
-        const allRelations = manyToOneScanner
-            .allMetadata()
-            .filter((rel) => rel.target === entity);
-        if (allRelations.length > 0) {
-            return this.resolveJoinColumnsFromColumnMeta(entity, allRelations);
-        }
-        const reflectMetadata = Reflect.getMetadata(decorators_1.MANY_TO_ONE_TOKEN, entity) ??
-            Reflect.getMetadata(decorators_1.MANY_TO_ONE_TOKEN, entity.prototype);
-        if (reflectMetadata && reflectMetadata.length > 0) {
-            this.logger.warn(`[resolveManyToOneMetadata] "${entity.name}" ManyToOne resolved via Reflect.getMetadata fallback.`);
-            return this.resolveJoinColumnsFromColumnMeta(entity, reflectMetadata);
-        }
-        return [];
-    }
-    resolveJoinColumnsFromColumnMeta(entity, relations) {
-        const columnsMeta = Reflect.getMetadata(decorators_1.COLUMN_TOKEN, entity) ??
-            Reflect.getMetadata(decorators_1.COLUMN_TOKEN, entity.prototype) ??
-            [];
-        if (columnsMeta.length === 0) {
-            return relations;
-        }
-        return relations.map((rel) => {
-            if (rel.joinColumn)
-                return rel;
-            const fkPropertyName = `${rel.columnName}Id`;
-            const matchingColumn = columnsMeta.find((col) => col.propertyKey === fkPropertyName);
-            if (!matchingColumn)
-                return rel;
-            const resolvedJoinColumn = matchingColumn.name ?? fkPropertyName;
-            return {
-                ...rel,
-                joinColumn: resolvedJoinColumn,
-            };
-        });
-    }
-    resolveOneToManyMetadata(entity) {
-        const oneToManyScanner = typedi_1.default.get(scanner_1.OneToManyScanner);
-        const allRelations = oneToManyScanner
-            .allMetadata()
-            .filter((rel) => rel.target === entity);
-        if (allRelations.length > 0) {
-            return allRelations;
-        }
-        const reflectMetadata = Reflect.getMetadata(decorators_1.ONE_TO_MANY_TOKEN, entity) ??
-            Reflect.getMetadata(decorators_1.ONE_TO_MANY_TOKEN, entity.prototype);
-        if (reflectMetadata && reflectMetadata.length > 0) {
-            this.logger.warn(`[resolveOneToManyMetadata] "${entity.name}" OneToMany resolved via Reflect.getMetadata fallback.`);
-            return reflectMetadata;
-        }
-        return [];
-    }
-    async loadOneToManyRelations(entity, parentResults, relations) {
-        const oneToManyMeta = this.resolveOneToManyMetadata(entity);
-        if (oneToManyMeta.length === 0)
-            return;
-        const parentMetadata = this.resolveEntityMetadata(entity);
-        if (!parentMetadata)
-            return;
-        const pk = parentMetadata.columns.find((column) => column.options?.primary);
-        if (!pk)
-            return;
-        const parents = Array.isArray(parentResults)
-            ? parentResults
-            : [parentResults];
-        for (const rel of oneToManyMeta) {
-            if (!relations.includes(rel.propertyKey))
-                continue;
-            const RelatedEntity = rel.getRelatedEntity();
-            const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
-            if (!relatedMetadata)
-                continue;
-            const manyToOneItems = this.resolveManyToOneMetadata(RelatedEntity);
-            const matchingRelation = manyToOneItems.find((m) => m.columnName === rel.mappedBy);
-            const fkColumn = matchingRelation?.joinColumn ?? rel.mappedBy;
-            for (const parent of parents) {
-                const parentId = parent[pk.name];
-                if (parentId === undefined || parentId === null)
-                    continue;
-                const children = await this.find(RelatedEntity, {
-                    where: { [fkColumn]: parentId },
-                });
-                if (children === undefined) {
-                    parent[rel.propertyKey] = [];
-                }
-                else if (Array.isArray(children)) {
-                    parent[rel.propertyKey] = children;
-                }
-                else {
-                    parent[rel.propertyKey] = [children];
-                }
-            }
-        }
-    }
-    resolveManyToManyMetadata(entity) {
-        const manyToManyScanner = typedi_1.default.get(scanner_1.ManyToManyScanner);
-        const allRelations = manyToManyScanner
-            .allMetadata()
-            .filter((rel) => rel.target === entity);
-        if (allRelations.length > 0) {
-            return allRelations;
-        }
-        const reflectMetadata = Reflect.getMetadata(decorators_1.MANY_TO_MANY_TOKEN, entity) ??
-            Reflect.getMetadata(decorators_1.MANY_TO_MANY_TOKEN, entity.prototype);
-        if (reflectMetadata && reflectMetadata.length > 0) {
-            this.logger.warn(`[resolveManyToManyMetadata] "${entity.name}" ManyToMany resolved via Reflect.getMetadata fallback.`);
-            return reflectMetadata;
-        }
-        return [];
-    }
-    resolveOneToOneMetadata(entity) {
-        const oneToOneScanner = typedi_1.default.get(scanner_1.OneToOneScanner);
-        const allRelations = oneToOneScanner
-            .allMetadata()
-            .filter((rel) => rel.target === entity);
-        if (allRelations.length > 0) {
-            return this.resolveJoinColumnsFromColumnMetaForOneToOne(entity, allRelations);
-        }
-        const reflectMetadata = Reflect.getMetadata(decorators_1.ONE_TO_ONE_TOKEN, entity) ??
-            Reflect.getMetadata(decorators_1.ONE_TO_ONE_TOKEN, entity.prototype);
-        if (reflectMetadata && reflectMetadata.length > 0) {
-            this.logger.warn(`[resolveOneToOneMetadata] "${entity.name}" OneToOne resolved via Reflect.getMetadata fallback.`);
-            return this.resolveJoinColumnsFromColumnMetaForOneToOne(entity, reflectMetadata);
-        }
-        return [];
-    }
-    resolveJoinColumnsFromColumnMetaForOneToOne(entity, relations) {
-        const columnsMeta = Reflect.getMetadata(decorators_1.COLUMN_TOKEN, entity) ??
-            Reflect.getMetadata(decorators_1.COLUMN_TOKEN, entity.prototype) ??
-            [];
-        if (columnsMeta.length === 0) {
-            return relations;
-        }
-        return relations.map((rel) => {
-            if (rel.joinColumn)
-                return rel;
-            const fkPropertyName = `${rel.propertyKey}Id`;
-            const matchingColumn = columnsMeta.find((col) => col.propertyKey === fkPropertyName);
-            if (!matchingColumn)
-                return rel;
-            const resolvedJoinColumn = matchingColumn.name ?? fkPropertyName;
-            return {
-                ...rel,
-                joinColumn: resolvedJoinColumn,
-            };
-        });
-    }
-    resolveManyToManyJoinTable(rel) {
-        if (rel.joinTable) {
-            return {
-                joinTableName: rel.joinTable.name,
-                joinColumn: rel.joinTable.joinColumn,
-                inverseJoinColumn: rel.joinTable.inverseJoinColumn,
-            };
-        }
-        if (rel.mappedBy) {
-            const RelatedEntity = rel.getRelatedEntity();
-            const relatedManyToMany = this.resolveManyToManyMetadata(RelatedEntity);
-            const ownerRel = relatedManyToMany.find((r) => r.propertyKey === rel.mappedBy && r.joinTable);
-            if (ownerRel?.joinTable) {
-                return {
-                    joinTableName: ownerRel.joinTable.name,
-                    joinColumn: ownerRel.joinTable.inverseJoinColumn,
-                    inverseJoinColumn: ownerRel.joinTable.joinColumn,
-                };
-            }
-        }
-        return null;
-    }
-    async loadManyToManyRelations(entity, parentResults, relations) {
-        const manyToManyMeta = this.resolveManyToManyMetadata(entity);
-        if (manyToManyMeta.length === 0)
-            return;
-        const parentMetadata = this.resolveEntityMetadata(entity);
-        if (!parentMetadata)
-            return;
-        const pk = parentMetadata.columns.find((column) => column.options?.primary);
-        if (!pk)
-            return;
-        const parents = Array.isArray(parentResults)
-            ? parentResults
-            : [parentResults];
-        for (const rel of manyToManyMeta) {
-            if (!relations.includes(rel.propertyKey))
-                continue;
-            const joinInfo = this.resolveManyToManyJoinTable(rel);
-            if (!joinInfo)
-                continue;
-            const RelatedEntity = rel.getRelatedEntity();
-            const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
-            if (!relatedMetadata)
-                continue;
-            const relatedPk = relatedMetadata.columns.find((col) => col.options?.primary);
-            if (!relatedPk)
-                continue;
-            const relatedTableName = relatedMetadata.name ?? RelatedEntity.name;
-            for (const parent of parents) {
-                const parentId = parent[pk.name];
-                if (parentId === undefined || parentId === null)
-                    continue;
-                const qb = RawQueryBuilderFactory_1.RawQueryBuilderFactory.create();
-                const selectCols = relatedMetadata.columns.map((col) => `${this.wrap(relatedTableName)}.${this.wrap(col.name)}`);
-                const joinCondition = (0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(relatedTableName))}.${(0, sql_template_tag_1.raw)(this.wrap(relatedPk.name))} = ${(0, sql_template_tag_1.raw)(this.wrap(joinInfo.joinTableName))}.${(0, sql_template_tag_1.raw)(this.wrap(joinInfo.inverseJoinColumn))}`;
-                const whereCondition = (0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(joinInfo.joinTableName))}.${(0, sql_template_tag_1.raw)(this.wrap(joinInfo.joinColumn))} = ${parentId}`;
-                qb.select(selectCols)
-                    .from(this.wrap(relatedTableName))
-                    .innerJoin(this.wrap(joinInfo.joinTableName), this.wrap(joinInfo.joinTableName), joinCondition)
-                    .where([whereCondition]);
-                const transactionHolder = new TransactionSessionManager_1.TransactionSessionManager();
-                try {
-                    await transactionHolder.connect();
-                    await transactionHolder.startTransaction();
-                    if (this.isMySqlFamily()) {
-                        await transactionHolder.query("SET autocommit = 0");
-                    }
-                    const resultQuery = qb.build();
-                    const subQueryStart = Date.now();
-                    this.beginTrackQuery();
-                    const queryResult = (await transactionHolder.query(resultQuery));
-                    this.trackQuery(relatedTableName, resultQuery.text ?? String(resultQuery), Date.now() - subQueryStart);
-                    await transactionHolder.commit();
-                    const resultTransformer = ResultTransformerFactory_1.ResultTransformerFactory.create();
-                    const { results } = queryResult;
-                    if (!results || results.length === 0) {
-                        parent[rel.propertyKey] = [];
-                    }
-                    else {
-                        parent[rel.propertyKey] = resultTransformer.toEntities(RelatedEntity, queryResult);
-                    }
-                }
-                catch (e) {
-                    try {
-                        await transactionHolder.rollback();
-                    }
-                    catch (rollbackError) {
-                        this.logger.error(`Failed to rollback ManyToMany transaction: ${rollbackError}`);
-                    }
-                    throw e;
-                }
-                finally {
-                    try {
-                        await transactionHolder.close();
-                    }
-                    catch (closeError) {
-                        this.logger.error(`Failed to close ManyToMany transaction: ${closeError}`);
-                    }
-                }
-            }
-        }
-    }
-    async loadOneToOneRelations(entity, parentResults, relations) {
-        const oneToOneMeta = this.resolveOneToOneMetadata(entity);
-        if (oneToOneMeta.length === 0)
-            return;
-        const parentMetadata = this.resolveEntityMetadata(entity);
-        if (!parentMetadata)
-            return;
-        const pk = parentMetadata.columns.find((column) => column.options?.primary);
-        if (!pk)
-            return;
-        const parents = Array.isArray(parentResults)
-            ? parentResults
-            : [parentResults];
-        for (const rel of oneToOneMeta) {
-            if (!relations.includes(rel.propertyKey))
-                continue;
-            if (rel.joinColumn) {
-                continue;
-            }
-            const RelatedEntity = rel.getRelatedEntity();
-            const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
-            if (!relatedMetadata)
-                continue;
-            const relatedPk = relatedMetadata.columns.find((col) => col.options?.primary);
-            if (!relatedPk)
-                continue;
-            for (const parent of parents) {
-                if (rel.joinColumn) {
-                    const fkValue = parent[rel.joinColumn];
-                    if (fkValue === undefined || fkValue === null) {
-                        parent[rel.propertyKey] = null;
-                        continue;
-                    }
-                    const related = await this.findOne(RelatedEntity, {
-                        where: { [relatedPk.name]: fkValue },
-                    });
-                    parent[rel.propertyKey] = related ?? null;
-                }
-                else if (rel.inverseSide) {
-                    const parentId = parent[pk.name];
-                    if (parentId === undefined || parentId === null) {
-                        parent[rel.propertyKey] = null;
-                        continue;
-                    }
-                    const relatedOneToOne = this.resolveOneToOneMetadata(RelatedEntity);
-                    const ownerRel = relatedOneToOne.find((r) => r.propertyKey === rel.inverseSide && r.joinColumn);
-                    if (ownerRel?.joinColumn) {
-                        const related = await this.findOne(RelatedEntity, {
-                            where: { [ownerRel.joinColumn]: parentId },
-                        });
-                        parent[rel.propertyKey] = related ?? null;
-                    }
-                    else {
-                        parent[rel.propertyKey] = null;
-                    }
-                }
-            }
-        }
-    }
-    async registerForeignKeys(TargetEntity, tableName) {
-        const entityScanner = typedi_1.default.get(scanner_1.EntityScanner);
-        const manyToOneItems = this.resolveManyToOneMetadata(TargetEntity);
-        const isValidManyToOne = manyToOneItems && manyToOneItems.length > 0;
-        if (isValidManyToOne) {
-            for (const manyToOneItem of manyToOneItems) {
-                const { joinColumn } = manyToOneItem;
-                const mappingEntity = manyToOneItem.getMappingEntity();
-                if (!mappingEntity) {
-                    throw new EntityNotFound_1.EntityNotFound(mappingEntity);
-                }
-                const mappingTableMetadata = entityScanner.scan(mappingEntity);
-                if (!mappingTableMetadata) {
-                    throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(mappingEntity.name);
-                }
-                if (!joinColumn) {
-                    throw new InvalidQueryError_1.InvalidQueryError("JoinColumn does not exist.");
-                }
-                const mappingTablePrimaryKey = manyToOneItem.references
-                    ? manyToOneItem.references
-                    : mappingTableMetadata.columns.find((e) => e.options?.primary)?.name;
-                if (!mappingTablePrimaryKey) {
-                    throw new PrimaryKeyNotFoundError_1.PrimaryKeyNotFoundError(mappingEntity.name);
-                }
-                const mappingTableName = mappingTableMetadata.name || this.getNameStrategy(mappingEntity);
-                if (this.driver) {
-                    const columnExists = await this.driver.hasColumn(tableName, joinColumn);
-                    if (!columnExists) {
-                        const fkColumnType = this.driver.castType("int") + " NULL";
-                        await this.driver.addColumn(tableName, joinColumn, fkColumnType);
-                    }
-                }
-                if (this.driver) {
-                    const fkName = this.driver.generateForeignKeyName(tableName, mappingTableName, joinColumn);
-                    const fkExists = await this.driver.hasForeignKey(tableName, fkName);
-                    if (fkExists)
-                        continue;
-                }
-                await this.driver?.addForeignKey(tableName, joinColumn, mappingTableName, mappingTablePrimaryKey);
-            }
-        }
-        const oneToOneItems = this.resolveOneToOneMetadata(TargetEntity);
-        for (const oneToOneItem of oneToOneItems) {
-            const { joinColumn } = oneToOneItem;
-            if (!joinColumn)
-                continue;
-            const RelatedEntity = oneToOneItem.getRelatedEntity();
-            if (!RelatedEntity) {
-                throw new EntityNotFound_1.EntityNotFound(RelatedEntity);
-            }
-            const relatedMetadata = entityScanner.scan(RelatedEntity);
-            if (!relatedMetadata) {
-                throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(RelatedEntity.name);
-            }
-            const relatedPrimaryKey = relatedMetadata.columns.find((e) => e.options?.primary)?.name;
-            if (!relatedPrimaryKey) {
-                throw new PrimaryKeyNotFoundError_1.PrimaryKeyNotFoundError(RelatedEntity.name);
-            }
-            if (this.driver) {
-                const columnExists = await this.driver.hasColumn(tableName, joinColumn);
-                if (!columnExists) {
-                    const fkColumnType = this.driver.castType("int") + " NULL";
-                    await this.driver.addColumn(tableName, joinColumn, fkColumnType);
-                }
-            }
-            const relatedTableName = relatedMetadata.name || this.getNameStrategy(RelatedEntity);
-            if (this.driver) {
-                const fkName = this.driver.generateForeignKeyName(tableName, relatedTableName, joinColumn);
-                const fkExists = await this.driver.hasForeignKey(tableName, fkName);
-                if (fkExists)
-                    continue;
-            }
-            await this.driver?.addForeignKey(tableName, joinColumn, relatedTableName, relatedPrimaryKey);
-        }
-    }
-    async registerIndex(TargetEntity, tableName) {
-        const indexer = Reflect.getMetadata(Indexer_1.INDEX_TOKEN, TargetEntity.prototype);
-        if (indexer) {
-            for (const index of indexer) {
-                const indexName = `INDEX_${tableName}_${index.name}`;
-                const indexes = (await this.driver?.getIndexes(tableName));
-                let isExist = false;
-                for (const idx of indexes || []) {
-                    const existingIndexName = idx["Key_name"] ?? idx["Field"];
-                    if (existingIndexName === indexName) {
-                        isExist = true;
-                        break;
-                    }
-                }
-                if (!isExist) {
-                    await this.driver?.addIndex(tableName, index.name, indexName);
-                }
-            }
-        }
-    }
     async findOne(entity, findOption) {
-        const result = await this.find(entity, { ...findOption, limit: 1 });
+        return this.findOneInternal(entity, findOption);
+    }
+    async findOneInternal(entity, findOption, existingSession) {
+        const result = await this.findInternal(entity, { ...findOption, limit: 1 }, existingSession);
         if (result === undefined || result === null) {
             return null;
         }
@@ -824,347 +280,16 @@ class EntityManager {
         }
         return result;
     }
-    async explain(entity, findOption = {}) {
-        if (!this.driver || !this.driver.supportsExplain()) {
-            throw new InvalidQueryError_1.InvalidQueryError("EXPLAIN is not supported by the current database driver.");
-        }
-        const { select, orderBy, where, take } = findOption;
-        const { limit } = findOption;
-        const metadata = this.resolveEntityMetadata(entity);
-        if (!metadata) {
-            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
-        }
-        const qb = RawQueryBuilderFactory_1.RawQueryBuilderFactory.create();
-        const selectMap = [];
-        const whereMap = [];
-        const orderByMap = [];
-        const manyToOneRelations = this.resolveManyToOneMetadata(entity);
-        const eagerRelations = manyToOneRelations.filter((rel) => {
-            const isEager = rel.option?.eager === true;
-            const isInRelations = findOption.relations?.includes(rel.columnName);
-            return isEager || isInRelations;
-        });
-        const oneToOneRelations = this.resolveOneToOneMetadata(entity);
-        const eagerOneToOneRelations = oneToOneRelations.filter((rel) => {
-            if (!rel.joinColumn)
-                return false;
-            const isEager = rel.option?.eager === true;
-            const isInRelations = findOption.relations?.includes(rel.propertyKey);
-            return isEager || isInRelations;
-        });
-        const hasEagerJoins = eagerRelations.length > 0 || eagerOneToOneRelations.length > 0;
-        const tableName = metadata.name;
-        if (select) {
-            const selectedColumns = this.resolveSelectColumns(select);
-            if (hasEagerJoins) {
-                selectMap.push(...selectedColumns.map((col) => `${this.wrap(tableName)}.${this.wrap(col)}`));
-            }
-            else {
-                selectMap.push(...selectedColumns.map((col) => this.wrap(col)));
-            }
-        }
-        else {
-            if (hasEagerJoins) {
-                selectMap.push(...metadata.columns.map((column) => `${this.wrap(tableName)}.${this.wrap(column.name)}`));
-            }
-            else {
-                selectMap.push(...metadata.columns.map((column) => this.wrap(column.name)));
-            }
-        }
-        for (const key in where) {
-            const value = where[key];
-            if (value !== undefined && value !== null) {
-                if (hasEagerJoins) {
-                    whereMap.push(Conditions_1.Conditions.equals(`${this.wrap(tableName)}.${this.wrap(key)}`, value));
-                }
-                else {
-                    whereMap.push(Conditions_1.Conditions.equals(this.wrap(key), value));
-                }
-            }
-        }
-        const deletedAtColumn = this.getDeletedAtColumn(entity);
-        if (deletedAtColumn && !findOption.withDeleted) {
-            if (hasEagerJoins) {
-                whereMap.push(Conditions_1.Conditions.isNull(`${this.wrap(tableName)}.${this.wrap(deletedAtColumn)}`));
-            }
-            else {
-                whereMap.push(Conditions_1.Conditions.isNull(this.wrap(deletedAtColumn)));
-            }
-        }
-        for (const key in orderBy) {
-            const value = orderBy[key];
-            if (value) {
-                orderByMap.push({ column: this.wrap(key), direction: value });
-            }
-        }
-        qb.select(selectMap).from(this.wrap(tableName));
-        qb.where(whereMap).orderBy(orderByMap);
-        if (Array.isArray(limit)) {
-            let [offset, count] = limit;
-            if (offset < 0)
-                offset = 0;
-            if (count < 0)
-                count = 0;
-            if (count === 0)
-                count = 1;
-            if (take && take > 0)
-                count = take;
-            if (this.isMySqlFamily())
-                qb.setDatabaseType("mysql");
-            qb.limit([offset, count]);
-        }
-        else if (limit) {
-            qb.limit(limit);
-        }
-        const selectQuery = qb.build();
-        const explainPrefix = this.driver.buildExplainSql("");
-        const explainQuery = (0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(explainPrefix)}${selectQuery}`;
-        const transactionHolder = new TransactionSessionManager_1.TransactionSessionManager();
-        try {
-            const readNode = this.getReadNode(findOption.useMaster);
-            if (readNode) {
-                await transactionHolder.connectToNode(readNode);
-            }
-            else {
-                await transactionHolder.connect();
-            }
-            await transactionHolder.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionHolder.query("SET autocommit = 0");
-            }
-            const result = await transactionHolder.query(explainQuery);
-            await transactionHolder.commit();
-            const rawRows = result?.results ?? [];
-            return this.parseExplainResult(rawRows);
-        }
-        catch (e) {
-            try {
-                await transactionHolder.rollback();
-            }
-            catch {
-            }
-            throw e;
-        }
-        finally {
-            try {
-                await transactionHolder.close();
-            }
-            catch {
-            }
-        }
-    }
-    parseExplainResult(rawRows) {
-        if (!rawRows || rawRows.length === 0) {
-            return {
-                raw: [],
-                rows: null,
-                type: null,
-                possibleKeys: null,
-                key: null,
-                cost: null,
-            };
-        }
-        const firstRow = rawRows[0];
-        if (firstRow && "QUERY PLAN" in firstRow) {
-            return this.parsePostgresExplain(firstRow["QUERY PLAN"]);
-        }
-        if ("type" in firstRow || "select_type" in firstRow) {
-            return this.parseMysqlExplain(rawRows);
-        }
-        if ("detail" in firstRow || "notused" in firstRow) {
-            return this.parseSqliteExplain(rawRows);
-        }
-        return {
-            raw: rawRows,
-            rows: null,
-            type: null,
-            possibleKeys: null,
-            key: null,
-            cost: null,
-        };
-    }
-    parseMysqlExplain(rawRows) {
-        const first = rawRows[0];
-        const rows = first.rows != null ? Number(first.rows) : null;
-        const type = first.type != null ? String(first.type) : null;
-        const possibleKeysRaw = first.possible_keys;
-        const possibleKeys = possibleKeysRaw != null
-            ? String(possibleKeysRaw)
-                .split(",")
-                .map((k) => k.trim())
-            : null;
-        const key = first.key != null ? String(first.key) : null;
-        const cost = first.filtered != null ? Number(first.filtered) : null;
-        return { raw: rawRows, rows, type, possibleKeys, key, cost };
-    }
-    parsePostgresExplain(queryPlan) {
-        const rawArray = Array.isArray(queryPlan) ? queryPlan : [queryPlan];
-        const plan = rawArray[0]?.Plan ?? rawArray[0]?.["Plan"] ?? null;
-        if (!plan) {
-            return {
-                raw: rawArray,
-                rows: null,
-                type: null,
-                possibleKeys: null,
-                key: null,
-                cost: null,
-            };
-        }
-        const rows = plan["Plan Rows"] != null ? Number(plan["Plan Rows"]) : null;
-        const type = plan["Node Type"] != null ? String(plan["Node Type"]) : null;
-        const key = plan["Index Name"] != null ? String(plan["Index Name"]) : null;
-        const cost = plan["Total Cost"] != null ? Number(plan["Total Cost"]) : null;
-        return { raw: rawArray, rows, type, possibleKeys: null, key, cost };
-    }
-    parseSqliteExplain(rawRows) {
-        const details = rawRows.map((r) => String(r.detail ?? ""));
-        const firstDetail = details[0] ?? "";
-        let type = null;
-        let key = null;
-        if (firstDetail.startsWith("SCAN"))
-            type = "SCAN";
-        else if (firstDetail.startsWith("SEARCH"))
-            type = "SEARCH";
-        const indexMatch = firstDetail.match(/USING (?:COVERING )?INDEX (\S+)/);
-        if (indexMatch)
-            key = indexMatch[1];
-        return {
-            raw: rawRows,
-            rows: null,
-            type,
-            possibleKeys: null,
-            key,
-            cost: null,
-        };
-    }
-    async findWithCursor(entity, option = {}) {
-        const metadata = this.resolveEntityMetadata(entity);
-        if (!metadata) {
-            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
-        }
-        const pk = metadata.columns.find((column) => column.options?.primary);
-        const orderByColumn = option.orderBy ?? pk?.name;
-        if (!orderByColumn) {
-            throw new InvalidQueryError_1.InvalidQueryError("Cursor pagination requires an orderBy column or a primary key.");
-        }
-        const direction = option.direction ?? "ASC";
-        const pageSize = (0, CursorPagination_1.normalizePageSize)(option.take);
-        let cursorValue = null;
-        if (option.cursor) {
-            cursorValue = (0, CursorPagination_1.decodeCursor)(option.cursor);
-            if (cursorValue === null) {
-                throw new InvalidQueryError_1.InvalidQueryError("Invalid cursor value.");
-            }
-        }
-        const where = { ...(option.where ?? {}) };
-        const transactionHolder = new TransactionSessionManager_1.TransactionSessionManager();
-        const resultTransformer = ResultTransformerFactory_1.ResultTransformerFactory.create();
-        try {
-            const readNode = this.getReadNode(option.useMaster);
-            if (readNode) {
-                await transactionHolder.connectToNode(readNode);
-            }
-            else {
-                await transactionHolder.connect();
-            }
-            await transactionHolder.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionHolder.query("SET autocommit = 0");
-            }
-            const tableName = metadata.name;
-            const qb = RawQueryBuilderFactory_1.RawQueryBuilderFactory.create();
-            const selectMap = metadata.columns.map((column) => this.wrap(column.name));
-            const whereMap = [];
-            for (const key in where) {
-                const value = where[key];
-                if (value !== undefined && value !== null) {
-                    whereMap.push(Conditions_1.Conditions.equals(this.wrap(key), value));
-                }
-            }
-            const deletedAtColumn = this.getDeletedAtColumn(entity);
-            if (deletedAtColumn) {
-                whereMap.push(Conditions_1.Conditions.isNull(this.wrap(deletedAtColumn)));
-            }
-            if (cursorValue !== null) {
-                if (direction === "ASC") {
-                    whereMap.push(Conditions_1.Conditions.gt(this.wrap(orderByColumn), cursorValue));
-                }
-                else {
-                    whereMap.push(Conditions_1.Conditions.lt(this.wrap(orderByColumn), cursorValue));
-                }
-            }
-            qb.select(selectMap)
-                .from(this.wrap(tableName))
-                .where(whereMap)
-                .orderBy([{ column: this.wrap(orderByColumn), direction }]);
-            qb.limit(pageSize + 1);
-            const resultQuery = qb.build();
-            const queryResult = (await transactionHolder.query(resultQuery));
-            await transactionHolder.commit();
-            const { results } = queryResult;
-            if (!results || results.length === 0) {
-                return {
-                    data: [],
-                    hasNextPage: false,
-                    nextCursor: null,
-                    count: 0,
-                };
-            }
-            const hasNextPage = results.length > pageSize;
-            const pageResults = hasNextPage ? results.slice(0, pageSize) : results;
-            const entities = resultTransformer.toEntities(entity, {
-                results: pageResults,
-                fields: queryResult.fields,
-            });
-            let nextCursor = null;
-            if (hasNextPage && pageResults.length > 0) {
-                const lastItem = pageResults[pageResults.length - 1];
-                const lastValue = lastItem[orderByColumn];
-                nextCursor = (0, CursorPagination_1.encodeCursor)(lastValue);
-            }
-            return {
-                data: entities,
-                hasNextPage,
-                nextCursor,
-                count: entities.length,
-            };
-        }
-        catch (e) {
-            try {
-                await transactionHolder.rollback();
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback transaction: ${rollbackError}`);
-            }
-            throw e;
-        }
-        finally {
-            try {
-                await transactionHolder.close();
-            }
-            catch (closeError) {
-                this.logger.error(`Failed to close transaction: ${closeError}`);
-            }
-        }
-    }
     async find(entity, findOption = {}) {
+        return this.findInternal(entity, findOption);
+    }
+    async findInternal(entity, findOption = {}, existingSession) {
         const { select, orderBy, where, take, groupBy, having } = findOption;
         const { limit } = findOption;
-        const transactionHolder = new TransactionSessionManager_1.TransactionSessionManager();
-        const resultTransformer = ResultTransformerFactory_1.ResultTransformerFactory.create();
-        try {
-            const readNode = this.getReadNode(findOption.useMaster);
-            if (readNode) {
-                await transactionHolder.connectToNode(readNode);
-            }
-            else {
-                await transactionHolder.connect();
-            }
-            await transactionHolder.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionHolder.query("SET autocommit = 0");
-            }
-            const metadata = this.resolveEntityMetadata(entity);
+        const readNode = this.getReadNode(findOption.useMaster);
+        return this.executeInTransaction(async (session) => {
+            const resultTransformer = ResultTransformerFactory_1.ResultTransformerFactory.create();
+            const metadata = this.resolver.resolveEntityMetadata(entity);
             if (!metadata) {
                 throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
             }
@@ -1172,13 +297,13 @@ class EntityManager {
             const selectMap = [];
             const whereMap = [];
             const orderByMap = [];
-            const manyToOneRelations = this.resolveManyToOneMetadata(entity);
+            const manyToOneRelations = this.resolver.resolveManyToOneMetadata(entity);
             const eagerRelations = manyToOneRelations.filter((rel) => {
                 const isEager = rel.option?.eager === true;
                 const isInRelations = findOption.relations?.includes(rel.columnName);
                 return isEager || isInRelations;
             });
-            const oneToOneRelations = this.resolveOneToOneMetadata(entity);
+            const oneToOneRelations = this.resolver.resolveOneToOneMetadata(entity);
             const eagerOneToOneRelations = oneToOneRelations.filter((rel) => {
                 if (!rel.joinColumn)
                     return false;
@@ -1207,7 +332,7 @@ class EntityManager {
             }
             for (const rel of eagerRelations) {
                 const RelatedEntity = rel.getMappingEntity();
-                const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
+                const relatedMetadata = this.resolver.resolveEntityMetadata(RelatedEntity);
                 if (!relatedMetadata)
                     continue;
                 const relatedName = relatedMetadata.name || RelatedEntity.name;
@@ -1218,7 +343,7 @@ class EntityManager {
             }
             for (const rel of eagerOneToOneRelations) {
                 const RelatedEntity = rel.getRelatedEntity();
-                const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
+                const relatedMetadata = this.resolver.resolveEntityMetadata(RelatedEntity);
                 if (!relatedMetadata)
                     continue;
                 const relatedName = relatedMetadata.name || RelatedEntity.name;
@@ -1238,7 +363,7 @@ class EntityManager {
                     }
                 }
             }
-            const deletedAtColumn = this.getDeletedAtColumn(entity);
+            const deletedAtColumn = this.resolver.getDeletedAtColumn(entity);
             if (deletedAtColumn && !findOption.withDeleted) {
                 if (hasEagerJoins) {
                     whereMap.push(Conditions_1.Conditions.isNull(`${this.wrap(tableName)}.${this.wrap(deletedAtColumn)}`));
@@ -1256,7 +381,7 @@ class EntityManager {
             qb.select(selectMap).from(this.wrap(tableName));
             for (const rel of eagerRelations) {
                 const RelatedEntity = rel.getMappingEntity();
-                const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
+                const relatedMetadata = this.resolver.resolveEntityMetadata(RelatedEntity);
                 if (!relatedMetadata)
                     continue;
                 const relatedTableName = relatedMetadata.name || RelatedEntity.name;
@@ -1269,7 +394,7 @@ class EntityManager {
             }
             for (const rel of eagerOneToOneRelations) {
                 const RelatedEntity = rel.getRelatedEntity();
-                const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
+                const relatedMetadata = this.resolver.resolveEntityMetadata(RelatedEntity);
                 if (!relatedMetadata)
                     continue;
                 const relatedTableName = relatedMetadata.name || RelatedEntity.name;
@@ -1293,21 +418,16 @@ class EntityManager {
             qb.orderBy(orderByMap);
             if (Array.isArray(limit)) {
                 let [offset, count] = limit;
-                if (offset < 0) {
+                if (offset < 0)
                     offset = 0;
-                }
-                if (count < 0) {
+                if (count < 0)
                     count = 0;
-                }
-                if (count === 0) {
+                if (count === 0)
                     count = 1;
-                }
-                if (take && take > 0) {
+                if (take && take > 0)
                     count = take;
-                }
-                if (this.isMySqlFamily()) {
+                if (this.isMySqlFamily())
                     qb.setDatabaseType("mysql");
-                }
                 qb.limit([offset, count]);
             }
             else {
@@ -1319,13 +439,12 @@ class EntityManager {
             const effectiveTimeout = findOption.timeout ?? this.defaultQueryTimeout;
             if (effectiveTimeout && effectiveTimeout > 0 && this.driver) {
                 const timeoutSql = this.driver.setQueryTimeout(effectiveTimeout);
-                await transactionHolder.query(timeoutSql);
+                await session.query(timeoutSql);
             }
             const queryStartTime = Date.now();
             this.beginTrackQuery();
-            const queryResult = (await transactionHolder.query(resultQuery));
+            const queryResult = (await session.query(resultQuery));
             this.trackQuery(entity.name, resultQuery.text ?? String(resultQuery), Date.now() - queryStartTime);
-            await transactionHolder.commit();
             const { results } = queryResult;
             if (!results || results.length === 0) {
                 return undefined;
@@ -1344,9 +463,9 @@ class EntityManager {
             if (findOption.relations &&
                 findOption.relations.length > 0 &&
                 entityResult) {
-                await this.loadOneToManyRelations(entity, entityResult, findOption.relations);
-                await this.loadManyToManyRelations(entity, entityResult, findOption.relations);
-                await this.loadOneToOneRelations(entity, entityResult, findOption.relations);
+                await this.relationLoader.loadOneToManyRelations(entity, entityResult, findOption.relations, session);
+                await this.relationLoader.loadManyToManyRelations(entity, entityResult, findOption.relations, session);
+                await this.relationLoader.loadOneToOneRelations(entity, entityResult, findOption.relations, session);
             }
             const lazyRelations = manyToOneRelations.filter((rel) => {
                 return rel.option?.lazy === true && rel.option?.eager !== true;
@@ -1362,7 +481,7 @@ class EntityManager {
                         const fkValue = item[joinColumn];
                         if (fkValue === undefined || fkValue === null)
                             continue;
-                        const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
+                        const relatedMetadata = this.resolver.resolveEntityMetadata(RelatedEntity);
                         if (!relatedMetadata)
                             continue;
                         const relatedPk = relatedMetadata.columns.find((col) => col.options?.primary);
@@ -1378,69 +497,111 @@ class EntityManager {
                     }
                 }
             }
-            return entityResult;
-        }
-        catch (e) {
-            try {
-                await transactionHolder.rollback();
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback transaction: ${rollbackError}`);
+            return entityResult;
+        }, existingSession, readNode);
+    }
+    async findWithCursor(entity, option = {}) {
+        const metadata = this.resolver.resolveEntityMetadata(entity);
+        if (!metadata) {
+            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
+        }
+        const pk = metadata.columns.find((column) => column.options?.primary);
+        const orderByColumn = option.orderBy ?? pk?.name;
+        if (!orderByColumn) {
+            throw new InvalidQueryError_1.InvalidQueryError("Cursor pagination requires an orderBy column or a primary key.");
+        }
+        if (!option.orderBy && pk) {
+            this.warnIfNonSortablePk(entity.name, pk);
+        }
+        const direction = option.direction ?? "ASC";
+        const pageSize = (0, CursorPagination_1.normalizePageSize)(option.take);
+        let cursorValue = null;
+        if (option.cursor) {
+            cursorValue = (0, CursorPagination_1.decodeCursor)(option.cursor);
+            if (cursorValue === null) {
+                throw new InvalidQueryError_1.InvalidQueryError("Invalid cursor value.");
+            }
+        }
+        const where = { ...(option.where ?? {}) };
+        const readNode = this.getReadNode(option.useMaster);
+        return this.executeInTransaction(async (session) => {
+            const resultTransformer = ResultTransformerFactory_1.ResultTransformerFactory.create();
+            const tableName = metadata.name;
+            const qb = RawQueryBuilderFactory_1.RawQueryBuilderFactory.create();
+            const selectMap = metadata.columns.map((column) => this.wrap(column.name));
+            const whereMap = [];
+            for (const key in where) {
+                const value = where[key];
+                if (value !== undefined && value !== null) {
+                    whereMap.push(Conditions_1.Conditions.equals(this.wrap(key), value));
+                }
+            }
+            const deletedAtColumn = this.resolver.getDeletedAtColumn(entity);
+            if (deletedAtColumn) {
+                whereMap.push(Conditions_1.Conditions.isNull(this.wrap(deletedAtColumn)));
             }
-            throw e;
-        }
-        finally {
-            try {
-                await transactionHolder.close();
+            if (cursorValue !== null) {
+                if (direction === "ASC") {
+                    whereMap.push(Conditions_1.Conditions.gt(this.wrap(orderByColumn), cursorValue));
+                }
+                else {
+                    whereMap.push(Conditions_1.Conditions.lt(this.wrap(orderByColumn), cursorValue));
+                }
             }
-            catch (closeError) {
-                this.logger.error(`Failed to close transaction: ${closeError}`);
+            qb.select(selectMap)
+                .from(this.wrap(tableName))
+                .where(whereMap)
+                .orderBy([{ column: this.wrap(orderByColumn), direction }]);
+            qb.limit(pageSize + 1);
+            const resultQuery = qb.build();
+            const queryResult = (await session.query(resultQuery));
+            const { results } = queryResult;
+            if (!results || results.length === 0) {
+                return {
+                    data: [],
+                    hasNextPage: false,
+                    nextCursor: null,
+                    count: 0,
+                };
             }
-        }
-    }
-    resolveSelectColumns(select) {
-        if (Array.isArray(select)) {
-            return select.map((col) => String(col));
-        }
-        const columns = [];
-        for (const key in select) {
-            if (select[key] === true) {
-                columns.push(key);
+            const hasNextPage = results.length > pageSize;
+            const pageResults = hasNextPage ? results.slice(0, pageSize) : results;
+            const entities = resultTransformer.toEntities(entity, {
+                results: pageResults,
+                fields: queryResult.fields,
+            });
+            let nextCursor = null;
+            if (hasNextPage && pageResults.length > 0) {
+                const lastItem = pageResults[pageResults.length - 1];
+                const lastValue = lastItem[orderByColumn];
+                nextCursor = (0, CursorPagination_1.encodeCursor)(lastValue);
             }
-        }
-        return columns;
-    }
-    wrap(columnName) {
-        if (this.driver && "wrap" in this.driver) {
-            return this.driver.wrap(columnName);
-        }
-        if (this.isPostgres()) {
-            return `"${columnName.replace(/"/g, '""')}"`;
-        }
-        return `\`${columnName.replace(/`/g, "``")}\``;
-    }
-    isMySqlFamily() {
-        const t = this.dbType ?? this.client.type;
-        return ["mysql", "mariadb"].includes(t);
+            return {
+                data: entities,
+                hasNextPage,
+                nextCursor,
+                count: entities.length,
+            };
+        }, undefined, readNode);
     }
-    isPostgres() {
-        const t = this.dbType ?? this.client.type;
-        return t === "postgres";
+    async findAndCount(entity, findOption = {}) {
+        return this.executeInTransaction(async (session) => {
+            const entities = await this.findInternal(entity, findOption, session);
+            const totalCount = await this.aggregateHandler.aggregate(entity, "COUNT", "*", findOption.where, session);
+            return [entities, totalCount];
+        });
     }
     async save(entity, item) {
-        const metadata = this.resolveEntityMetadata(entity);
+        return this.saveInternal(entity, item);
+    }
+    async saveInternal(entity, item, existingSession) {
+        const metadata = this.resolver.resolveEntityMetadata(entity);
         if (!metadata) {
             throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
         }
         EntityValidator_1.EntityValidator.validate(entity, item);
-        await this.cascadeSaveManyToOne(entity, item);
-        const transactionManager = new TransactionSessionManager_1.TransactionSessionManager();
-        try {
-            await transactionManager.connect();
-            await transactionManager.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionManager.query("SET autocommit = 0");
-            }
+        await this.cascadeHandler.cascadeSaveManyToOne(entity, item);
+        return this.executeInTransaction(async (session) => {
             const pkColumns = metadata.columns.filter((column) => column.options?.primary);
             const pk = pkColumns[0];
             const hasAutoIncrementPk = pkColumns.some((col) => col.options?.autoIncrement);
@@ -1466,7 +627,7 @@ class EntityManager {
                 return where;
             };
             if (isInsert) {
-                await this.runHooks(entity, item, "beforeInsert");
+                await this.cascadeHandler.runHooks(entity, item, "beforeInsert");
                 await this.eventEmitter.emit("beforeInsert", { entity, data: item });
                 await this.notifySubscribers(entity, "beforeInsert", {
                     entity: item,
@@ -1486,7 +647,29 @@ class EntityManager {
                 const values = insertableColumns.map((column) => {
                     return item[column.name];
                 });
-                const manyToOneRelations = this.resolveManyToOneMetadata(entity);
+                const now = new Date().toISOString();
+                const createTsCol = this.resolver.getCreateTimestampColumn(entity);
+                if (createTsCol) {
+                    const idx = insertableColumns.findIndex((col) => col.name === createTsCol);
+                    if (idx >= 0) {
+                        values[idx] = item[createTsCol]?.toISOString?.() ?? now;
+                    }
+                }
+                const updateTsCol = this.resolver.getUpdateTimestampColumn(entity);
+                if (updateTsCol) {
+                    const idx = insertableColumns.findIndex((col) => col.name === updateTsCol);
+                    if (idx >= 0) {
+                        values[idx] = item[updateTsCol]?.toISOString?.() ?? now;
+                    }
+                }
+                const versionCol = this.resolver.getVersionColumn(entity);
+                if (versionCol) {
+                    const versionIdx = insertableColumns.findIndex((col) => col.name === versionCol);
+                    if (versionIdx >= 0) {
+                        values[versionIdx] = 1;
+                    }
+                }
+                const manyToOneRelations = this.resolver.resolveManyToOneMetadata(entity);
                 for (const rel of manyToOneRelations) {
                     if (!rel.joinColumn)
                         continue;
@@ -1499,7 +682,7 @@ class EntityManager {
                     }
                     else if (relatedValue && typeof relatedValue === "object") {
                         const RelatedEntity = rel.getMappingEntity();
-                        const relatedMeta = this.resolveEntityMetadata(RelatedEntity);
+                        const relatedMeta = this.resolver.resolveEntityMetadata(RelatedEntity);
                         if (relatedMeta) {
                             const relatedPk = relatedMeta.columns.find((col) => col.options?.primary);
                             if (relatedPk) {
@@ -1534,21 +717,20 @@ class EntityManager {
                     `;
                 const saveQueryStart = Date.now();
                 this.beginTrackQuery();
-                const queryResult = (await transactionManager.query(insertSql));
+                const queryResult = (await session.query(insertSql));
                 this.trackQuery(entity.name, insertSql.text ?? String(insertSql), Date.now() - saveQueryStart);
-                await transactionManager.commit();
                 if (this.isMySqlFamily()) {
                     const findWhere = hasAutoIncrementPk
                         ? { [pk.name]: queryResult?.results?.insertId }
                         : buildPkFindWhere();
-                    const result = await this.findOne(entity, {
+                    const result = await this.findOneInternal(entity, {
                         where: findWhere,
-                    });
+                    }, session);
                     const cascadeId = hasAutoIncrementPk
                         ? queryResult?.results?.insertId
                         : primaryKeyValue;
-                    await this.cascadeSaveOneToMany(entity, item, cascadeId);
-                    await this.runHooks(entity, item, "afterInsert");
+                    await this.cascadeHandler.cascadeSaveOneToMany(entity, item, cascadeId);
+                    await this.cascadeHandler.runHooks(entity, item, "afterInsert");
                     await this.eventEmitter.emit("afterInsert", { entity, data: item });
                     await this.notifySubscribers(entity, "afterInsert", {
                         entity: item,
@@ -1559,12 +741,12 @@ class EntityManager {
                 if (isPostgres && queryResult?.results?.length > 0) {
                     const returnedRow = queryResult.results[0];
                     const findWhere = buildPkFindWhere(returnedRow);
-                    const result = await this.findOne(entity, {
+                    const result = await this.findOneInternal(entity, {
                         where: findWhere,
-                    });
+                    }, session);
                     const cascadeId = returnedRow[pk.name];
-                    await this.cascadeSaveOneToMany(entity, item, cascadeId);
-                    await this.runHooks(entity, item, "afterInsert");
+                    await this.cascadeHandler.cascadeSaveOneToMany(entity, item, cascadeId);
+                    await this.cascadeHandler.runHooks(entity, item, "afterInsert");
                     await this.eventEmitter.emit("afterInsert", { entity, data: item });
                     await this.notifySubscribers(entity, "afterInsert", {
                         entity: item,
@@ -1572,7 +754,7 @@ class EntityManager {
                     });
                     return result;
                 }
-                await this.runHooks(entity, item, "afterInsert");
+                await this.cascadeHandler.runHooks(entity, item, "afterInsert");
                 await this.eventEmitter.emit("afterInsert", { entity, data: item });
                 await this.notifySubscribers(entity, "afterInsert", {
                     entity: item,
@@ -1580,23 +762,38 @@ class EntityManager {
                 });
                 return queryResult;
             }
-            await this.runHooks(entity, item, "beforeUpdate");
+            await this.cascadeHandler.runHooks(entity, item, "beforeUpdate");
             await this.eventEmitter.emit("beforeUpdate", { entity, data: item });
             await this.notifySubscribers(entity, "beforeUpdate", {
                 entity: item,
                 manager: this,
             });
+            const versionColName = this.resolver.getVersionColumn(entity);
             const pkColumnNames = new Set(pkColumns.map((col) => col.name));
             const updatableColumns = metadata.columns.filter((column) => {
                 if (pkColumnNames.has(column.name))
                     return false;
+                if (versionColName && column.name === versionColName)
+                    return false;
                 return item[column.name] !== undefined;
             });
             const updateMap = updatableColumns.map((column) => {
                 return (0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(column.name))} = ${item[column.name]}`;
             });
+            const updateTsColName = this.resolver.getUpdateTimestampColumn(entity);
+            if (updateTsColName) {
+                const existingIdx = updatableColumns.findIndex((col) => col.name === updateTsColName);
+                const updateNow = new Date().toISOString();
+                if (existingIdx >= 0) {
+                    updateMap[existingIdx] =
+                        (0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(updateTsColName))} = ${updateNow}`;
+                }
+                else {
+                    updateMap.push((0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(updateTsColName))} = ${updateNow}`);
+                }
+            }
             const updatedColumnNames = new Set(updatableColumns.map((col) => col.name));
-            const updateManyToOneRelations = this.resolveManyToOneMetadata(entity);
+            const updateManyToOneRelations = this.resolver.resolveManyToOneMetadata(entity);
             for (const rel of updateManyToOneRelations) {
                 if (!rel.joinColumn)
                     continue;
@@ -1617,7 +814,7 @@ class EntityManager {
                 }
                 else if (typeof relatedValue === "object") {
                     const RelatedEntity = rel.getMappingEntity();
-                    const relatedMeta = this.resolveEntityMetadata(RelatedEntity);
+                    const relatedMeta = this.resolver.resolveEntityMetadata(RelatedEntity);
                     if (relatedMeta) {
                         const relatedPk = relatedMeta.columns.find((col) => col.options?.primary);
                         if (relatedPk) {
@@ -1638,6 +835,15 @@ class EntityManager {
                 }
             }
             const pkWhereClauses = buildPkWhere();
+            const currentVersion = versionColName
+                ? item[versionColName]
+                : undefined;
+            if (versionColName) {
+                updateMap.push((0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(versionColName))} = ${(0, sql_template_tag_1.raw)(this.wrap(versionColName))} + 1`);
+                if (currentVersion !== undefined && currentVersion !== null) {
+                    pkWhereClauses.push((0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(versionColName))} = ${currentVersion}`);
+                }
+            }
             if (updateMap.length > 0) {
                 const updateSql = (0, sql_template_tag_1.default) `
             UPDATE ${(0, sql_template_tag_1.raw)(this.wrap(metadata.name))}
@@ -1646,117 +852,57 @@ class EntityManager {
                   `;
                 const updateStart = Date.now();
                 this.beginTrackQuery();
-                await transactionManager.query(updateSql);
+                const updateResult = (await session.query(updateSql));
                 this.trackQuery(entity.name, updateSql.text ?? String(updateSql), Date.now() - updateStart);
+                if (versionColName && currentVersion !== undefined && currentVersion !== null) {
+                    let affected = 0;
+                    if (this.isMySqlFamily()) {
+                        affected = updateResult?.results?.affectedRows ?? 0;
+                    }
+                    else {
+                        affected = updateResult?.rowCount ?? 0;
+                    }
+                    if (affected === 0) {
+                        throw new OptimisticLockError_1.OptimisticLockError(entity.name, currentVersion);
+                    }
+                }
             }
-            await transactionManager.commit();
-            await this.cascadeSaveOneToMany(entity, item, primaryKeyValue);
-            await this.runHooks(entity, item, "afterUpdate");
+            await this.cascadeHandler.cascadeSaveOneToMany(entity, item, primaryKeyValue);
+            await this.cascadeHandler.runHooks(entity, item, "afterUpdate");
             await this.eventEmitter.emit("afterUpdate", { entity, data: item });
             await this.notifySubscribers(entity, "afterUpdate", {
                 entity: item,
                 manager: this,
             });
-            const result = await this.findOne(entity, {
+            const result = await this.findOneInternal(entity, {
                 where: buildPkFindWhere(),
-            });
+            }, session);
             return result;
-        }
-        catch (e) {
-            try {
-                await transactionManager.rollback();
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback transaction: ${rollbackError}`);
-            }
-            throw e;
-        }
-        finally {
-            try {
-                await transactionManager.close();
-            }
-            catch (closeError) {
-                this.logger.error(`Failed to close transaction: ${closeError}`);
-            }
-        }
-    }
-    async deleteMany(entity, ids) {
-        if (ids.length === 0) {
-            return { affected: 0 };
-        }
-        const metadata = this.resolveEntityMetadata(entity);
-        if (!metadata) {
-            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
-        }
-        const pk = metadata.columns.find((column) => column.options?.primary);
-        if (!pk) {
-            throw new PrimaryKeyNotFoundError_1.PrimaryKeyNotFoundError(entity.name);
-        }
-        const transactionManager = new TransactionSessionManager_1.TransactionSessionManager();
-        try {
-            await transactionManager.connect();
-            await transactionManager.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionManager.query("SET autocommit = 0");
-            }
-            const placeholders = (0, sql_template_tag_1.join)(ids.map((id) => (0, sql_template_tag_1.default) `${id}`), ", ");
-            const deleteQuery = (0, sql_template_tag_1.default) `DELETE FROM ${(0, sql_template_tag_1.raw)(this.wrap(metadata.name))} WHERE ${(0, sql_template_tag_1.raw)(this.wrap(pk.name))} IN (${placeholders})`;
-            const queryResult = (await transactionManager.query(deleteQuery));
-            await transactionManager.commit();
-            let affected = 0;
-            if (this.isMySqlFamily()) {
-                affected = queryResult?.results?.affectedRows ?? 0;
-            }
-            else {
-                affected = queryResult?.rowCount ?? 0;
-            }
-            return { affected };
-        }
-        catch (e) {
-            try {
-                await transactionManager.rollback();
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback transaction: ${rollbackError}`);
-            }
-            throw e;
-        }
-        finally {
-            try {
-                await transactionManager.close();
-            }
-            catch (closeError) {
-                this.logger.error(`Failed to close transaction: ${closeError}`);
-            }
-        }
+        }, existingSession);
     }
     async saveMany(entity, items) {
         if (items.length === 0) {
             return [];
         }
-        const results = [];
-        for (const item of items) {
-            const saved = await this.save(entity, item);
-            results.push(saved);
-        }
-        return results;
+        return this.executeInTransaction(async (session) => {
+            const results = [];
+            for (const item of items) {
+                const saved = await this.saveInternal(entity, item, session);
+                results.push(saved);
+            }
+            return results;
+        });
     }
     async insertMany(entity, items) {
         if (items.length === 0) {
             return { affected: 0 };
         }
-        const metadata = this.resolveEntityMetadata(entity);
+        const metadata = this.resolver.resolveEntityMetadata(entity);
         if (!metadata) {
             throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
         }
-        const transactionManager = new TransactionSessionManager_1.TransactionSessionManager();
-        try {
-            await transactionManager.connect();
-            await transactionManager.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionManager.query("SET autocommit = 0");
-            }
-            const deletedAtColumn = this.getDeletedAtColumn(entity);
+        return this.executeInTransaction(async (session) => {
+            const deletedAtColumn = this.resolver.getDeletedAtColumn(entity);
             const timestampTypes = new Set(["datetime", "timestamp", "date"]);
             const timestampColumns = metadata.columns.filter((col) => col.options?.type &&
                 timestampTypes.has(col.options.type) &&
@@ -1771,6 +917,14 @@ class EntityManager {
                     }
                 }
             }
+            const versionCol = this.resolver.getVersionColumn(entity);
+            if (versionCol) {
+                for (const item of items) {
+                    if (item[versionCol] == null) {
+                        item[versionCol] = 1;
+                    }
+                }
+            }
             const insertableColumns = metadata.columns.filter((column) => {
                 const isAutoIncrement = column.options?.autoIncrement;
                 if (!isAutoIncrement)
@@ -1779,7 +933,7 @@ class EntityManager {
                     item[column.name] !== undefined);
             });
             const columns = insertableColumns.map((column) => (0, sql_template_tag_1.raw)(this.wrap(column.name)));
-            const manyToOneRelations = this.resolveManyToOneMetadata(entity);
+            const manyToOneRelations = this.resolver.resolveManyToOneMetadata(entity);
             const fkColumns = [];
             for (const rel of manyToOneRelations) {
                 if (!rel.joinColumn)
@@ -1802,7 +956,7 @@ class EntityManager {
                     if (relatedValue != null) {
                         if (typeof relatedValue === "object") {
                             const RelatedEntity = fk.relMeta.getMappingEntity();
-                            const relatedMeta = this.resolveEntityMetadata(RelatedEntity);
+                            const relatedMeta = this.resolver.resolveEntityMetadata(RelatedEntity);
                             const relatedPk = relatedMeta?.columns.find((col) => col.options?.primary);
                             rowValues.push(relatedPk ? relatedValue[relatedPk.name] ?? null : null);
                         }
@@ -1817,143 +971,34 @@ class EntityManager {
                         rowValues.push(null);
                     }
                 }
-                return (0, sql_template_tag_1.default) `(${(0, sql_template_tag_1.join)(rowValues, ", ")})`;
-            });
-            const queryStr = (0, sql_template_tag_1.default) `INSERT INTO ${(0, sql_template_tag_1.raw)(this.wrap(metadata.name))} (${(0, sql_template_tag_1.join)(columns, ", ")}) VALUES ${(0, sql_template_tag_1.join)(valueRows, ", ")}`;
-            const queryResult = (await transactionManager.query(queryStr));
-            await transactionManager.commit();
-            let affected = items.length;
-            if (this.isMySqlFamily()) {
-                affected = queryResult?.results?.affectedRows ?? items.length;
-            }
-            else if (queryResult?.rowCount !== undefined) {
-                affected = queryResult.rowCount;
-            }
-            return { affected };
-        }
-        catch (e) {
-            try {
-                await transactionManager.rollback();
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback transaction: ${rollbackError}`);
-            }
-            throw e;
-        }
-        finally {
-            try {
-                await transactionManager.close();
-            }
-            catch (closeError) {
-                this.logger.error(`Failed to close transaction: ${closeError}`);
-            }
-        }
-    }
-    async upsert(entity, data, conflictColumns) {
-        const metadata = this.resolveEntityMetadata(entity);
-        if (!metadata) {
-            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
-        }
-        if (!this.driver) {
-            throw new Error("Driver is not initialized.");
-        }
-        const pkColumns = metadata.columns
-            .filter((col) => col.options?.primary)
-            .map((col) => col.name);
-        const resolvedConflictColumns = conflictColumns ?? pkColumns;
-        if (resolvedConflictColumns.length === 0) {
-            throw new PrimaryKeyNotFoundError_1.PrimaryKeyNotFoundError(entity.name);
-        }
-        const insertableColumns = metadata.columns.filter((col) => {
-            const value = data[col.name];
-            if (col.options?.autoIncrement &&
-                (value === null || value === undefined)) {
-                return false;
-            }
-            return value !== undefined;
-        });
-        if (insertableColumns.length === 0) {
-            return;
-        }
-        const conflictSet = new Set(resolvedConflictColumns);
-        const updateColumnNames = insertableColumns
-            .map((col) => col.name)
-            .filter((name) => !conflictSet.has(name));
-        const wrappedColumns = insertableColumns.map((col) => this.wrap(col.name));
-        const wrappedConflict = resolvedConflictColumns.map((name) => this.wrap(name));
-        const wrappedUpdate = updateColumnNames.map((name) => this.wrap(name));
-        const tableName = this.wrap(metadata.name);
-        if (wrappedUpdate.length === 0) {
-            return;
-        }
-        const transactionManager = new TransactionSessionManager_1.TransactionSessionManager();
-        try {
-            await transactionManager.connect();
-            await transactionManager.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionManager.query("SET autocommit = 0");
-            }
-            const columnValues = insertableColumns.map((col) => data[col.name]);
-            const upsertSql = this.buildUpsertQuery(tableName, wrappedColumns, columnValues, wrappedConflict, wrappedUpdate);
-            await transactionManager.query(upsertSql);
-            await transactionManager.commit();
-        }
-        catch (e) {
-            try {
-                await transactionManager.rollback();
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback transaction: ${rollbackError}`);
-            }
-            throw e;
-        }
-        finally {
-            try {
-                await transactionManager.close();
+                return (0, sql_template_tag_1.default) `(${(0, sql_template_tag_1.join)(rowValues, ", ")})`;
+            });
+            const queryStr = (0, sql_template_tag_1.default) `INSERT INTO ${(0, sql_template_tag_1.raw)(this.wrap(metadata.name))} (${(0, sql_template_tag_1.join)(columns, ", ")}) VALUES ${(0, sql_template_tag_1.join)(valueRows, ", ")}`;
+            const queryResult = (await session.query(queryStr));
+            let affected = items.length;
+            if (this.isMySqlFamily()) {
+                affected = queryResult?.results?.affectedRows ?? items.length;
             }
-            catch (closeError) {
-                this.logger.error(`Failed to close transaction: ${closeError}`);
+            else if (queryResult?.rowCount !== undefined) {
+                affected = queryResult.rowCount;
             }
-        }
-    }
-    buildUpsertQuery(tableName, columns, values, conflictColumns, updateColumns) {
-        const columnList = (0, sql_template_tag_1.join)(columns.map((c) => (0, sql_template_tag_1.raw)(c)), ", ");
-        const valueList = (0, sql_template_tag_1.join)(values, ", ");
-        if (this.isMySqlFamily()) {
-            const updateSet = (0, sql_template_tag_1.join)(updateColumns.map((col) => (0, sql_template_tag_1.raw)(`${col} = VALUES(${col})`)), ", ");
-            return (0, sql_template_tag_1.default) `INSERT INTO ${(0, sql_template_tag_1.raw)(tableName)} (${columnList}) VALUES (${valueList}) ON DUPLICATE KEY UPDATE ${updateSet}`;
-        }
-        const conflictList = (0, sql_template_tag_1.join)(conflictColumns.map((c) => (0, sql_template_tag_1.raw)(c)), ", ");
-        if (this.isPostgres()) {
-            const updateSet = (0, sql_template_tag_1.join)(updateColumns.map((col) => (0, sql_template_tag_1.raw)(`${col} = EXCLUDED.${col}`)), ", ");
-            return (0, sql_template_tag_1.default) `INSERT INTO ${(0, sql_template_tag_1.raw)(tableName)} (${columnList}) VALUES (${valueList}) ON CONFLICT (${conflictList}) DO UPDATE SET ${updateSet}`;
-        }
-        if ((this.dbType ?? this.client.type) === "sqlite") {
-            const updateSet = (0, sql_template_tag_1.join)(updateColumns.map((col) => (0, sql_template_tag_1.raw)(`${col} = excluded.${col}`)), ", ");
-            return (0, sql_template_tag_1.default) `INSERT INTO ${(0, sql_template_tag_1.raw)(tableName)} (${columnList}) VALUES (${valueList}) ON CONFLICT (${conflictList}) DO UPDATE SET ${updateSet}`;
-        }
-        throw new Error(`Unsupported database type for upsert: ${this.dbType}`);
+            return { affected };
+        });
     }
     async delete(entity, criteria) {
-        const metadata = this.resolveEntityMetadata(entity);
+        const metadata = this.resolver.resolveEntityMetadata(entity);
         if (!metadata) {
             throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
         }
-        const transactionManager = new TransactionSessionManager_1.TransactionSessionManager();
-        try {
-            await transactionManager.connect();
-            await transactionManager.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionManager.query("SET autocommit = 0");
-            }
-            await this.runHooks(entity, criteria, "beforeDelete");
+        return this.executeInTransaction(async (session) => {
+            await this.cascadeHandler.runHooks(entity, criteria, "beforeDelete");
             await this.eventEmitter.emit("beforeDelete", { entity, data: criteria });
             await this.notifySubscribers(entity, "beforeDelete", {
                 entityClass: entity,
                 criteria,
                 manager: this,
             });
-            await this.cascadeDeleteOneToMany(entity, criteria);
+            await this.cascadeHandler.cascadeDeleteOneToMany(entity, criteria);
             const whereMap = [];
             for (const key in criteria) {
                 const value = criteria[key];
@@ -1968,9 +1013,8 @@ class EntityManager {
             const deleteQuery = (0, sql_template_tag_1.default) `DELETE FROM ${(0, sql_template_tag_1.raw)(this.wrap(metadata.name))} WHERE ${whereSql}`;
             const deleteStart = Date.now();
             this.beginTrackQuery();
-            const queryResult = (await transactionManager.query(deleteQuery));
+            const queryResult = (await session.query(deleteQuery));
             this.trackQuery(entity.name, deleteQuery.text ?? String(deleteQuery), Date.now() - deleteStart);
-            await transactionManager.commit();
             let affected = 0;
             if (this.isMySqlFamily()) {
                 affected = queryResult?.results?.affectedRows ?? 0;
@@ -1978,7 +1022,7 @@ class EntityManager {
             else {
                 affected = queryResult?.rowCount ?? 0;
             }
-            await this.runHooks(entity, criteria, "afterDelete");
+            await this.cascadeHandler.runHooks(entity, criteria, "afterDelete");
             await this.eventEmitter.emit("afterDelete", { entity, data: criteria });
             await this.notifySubscribers(entity, "afterDelete", {
                 entityClass: entity,
@@ -1986,27 +1030,36 @@ class EntityManager {
                 manager: this,
             });
             return { affected };
+        });
+    }
+    async deleteMany(entity, ids) {
+        if (ids.length === 0) {
+            return { affected: 0 };
         }
-        catch (e) {
-            try {
-                await transactionManager.rollback();
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback transaction: ${rollbackError}`);
-            }
-            throw e;
+        const metadata = this.resolver.resolveEntityMetadata(entity);
+        if (!metadata) {
+            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
         }
-        finally {
-            try {
-                await transactionManager.close();
+        const pk = metadata.columns.find((column) => column.options?.primary);
+        if (!pk) {
+            throw new PrimaryKeyNotFoundError_1.PrimaryKeyNotFoundError(entity.name);
+        }
+        return this.executeInTransaction(async (session) => {
+            const placeholders = (0, sql_template_tag_1.join)(ids.map((id) => (0, sql_template_tag_1.default) `${id}`), ", ");
+            const deleteQuery = (0, sql_template_tag_1.default) `DELETE FROM ${(0, sql_template_tag_1.raw)(this.wrap(metadata.name))} WHERE ${(0, sql_template_tag_1.raw)(this.wrap(pk.name))} IN (${placeholders})`;
+            const queryResult = (await session.query(deleteQuery));
+            let affected = 0;
+            if (this.isMySqlFamily()) {
+                affected = queryResult?.results?.affectedRows ?? 0;
             }
-            catch (closeError) {
-                this.logger.error(`Failed to close transaction: ${closeError}`);
+            else {
+                affected = queryResult?.rowCount ?? 0;
             }
-        }
+            return { affected };
+        });
     }
     async clear(entity) {
-        const metadata = this.resolveEntityMetadata(entity);
+        const metadata = this.resolver.resolveEntityMetadata(entity);
         if (!metadata) {
             throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
         }
@@ -2016,21 +1069,15 @@ class EntityManager {
         await this.driver.clear(metadata.name);
     }
     async softDelete(entity, criteria) {
-        const metadata = this.resolveEntityMetadata(entity);
+        const metadata = this.resolver.resolveEntityMetadata(entity);
         if (!metadata) {
             throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
         }
-        const deletedAtColumn = this.getDeletedAtColumn(entity);
+        const deletedAtColumn = this.resolver.getDeletedAtColumn(entity);
         if (!deletedAtColumn) {
             throw new InvalidQueryError_1.InvalidQueryError(`Entity "${entity.name}" does not have a @DeletedAt column. Use delete() instead.`);
         }
-        const transactionManager = new TransactionSessionManager_1.TransactionSessionManager();
-        try {
-            await transactionManager.connect();
-            await transactionManager.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionManager.query("SET autocommit = 0");
-            }
+        return this.executeInTransaction(async (session) => {
             const whereMap = [];
             for (const key in criteria) {
                 const value = criteria[key];
@@ -2044,8 +1091,7 @@ class EntityManager {
             const whereSql = (0, sql_template_tag_1.join)(whereMap, " AND ");
             const nowExpr = this.isPostgres() ? (0, sql_template_tag_1.raw)("NOW()") : (0, sql_template_tag_1.raw)("NOW()");
             const updateQuery = (0, sql_template_tag_1.default) `UPDATE ${(0, sql_template_tag_1.raw)(this.wrap(metadata.name))} SET ${(0, sql_template_tag_1.raw)(this.wrap(deletedAtColumn))} = ${nowExpr} WHERE ${whereSql}`;
-            const queryResult = (await transactionManager.query(updateQuery));
-            await transactionManager.commit();
+            const queryResult = (await session.query(updateQuery));
             let affected = 0;
             if (this.isMySqlFamily()) {
                 affected = queryResult?.results?.affectedRows ?? 0;
@@ -2054,41 +1100,18 @@ class EntityManager {
                 affected = queryResult?.rowCount ?? 0;
             }
             return { affected };
-        }
-        catch (e) {
-            try {
-                await transactionManager.rollback();
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback transaction: ${rollbackError}`);
-            }
-            throw e;
-        }
-        finally {
-            try {
-                await transactionManager.close();
-            }
-            catch (closeError) {
-                this.logger.error(`Failed to close transaction: ${closeError}`);
-            }
-        }
+        });
     }
     async restore(entity, criteria) {
-        const metadata = this.resolveEntityMetadata(entity);
+        const metadata = this.resolver.resolveEntityMetadata(entity);
         if (!metadata) {
             throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
         }
-        const deletedAtColumn = this.getDeletedAtColumn(entity);
+        const deletedAtColumn = this.resolver.getDeletedAtColumn(entity);
         if (!deletedAtColumn) {
             throw new InvalidQueryError_1.InvalidQueryError(`Entity "${entity.name}" does not have a @DeletedAt column. Cannot restore.`);
         }
-        const transactionManager = new TransactionSessionManager_1.TransactionSessionManager();
-        try {
-            await transactionManager.connect();
-            await transactionManager.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionManager.query("SET autocommit = 0");
-            }
+        return this.executeInTransaction(async (session) => {
             const whereMap = [];
             for (const key in criteria) {
                 const value = criteria[key];
@@ -2101,8 +1124,7 @@ class EntityManager {
             }
             const whereSql = (0, sql_template_tag_1.join)(whereMap, " AND ");
             const restoreQuery = (0, sql_template_tag_1.default) `UPDATE ${(0, sql_template_tag_1.raw)(this.wrap(metadata.name))} SET ${(0, sql_template_tag_1.raw)(this.wrap(deletedAtColumn))} = NULL WHERE ${whereSql}`;
-            const queryResult = (await transactionManager.query(restoreQuery));
-            await transactionManager.commit();
+            const queryResult = (await session.query(restoreQuery));
             let affected = 0;
             if (this.isMySqlFamily()) {
                 affected = queryResult?.results?.affectedRows ?? 0;
@@ -2111,138 +1133,167 @@ class EntityManager {
                 affected = queryResult?.rowCount ?? 0;
             }
             return { affected };
+        });
+    }
+    async upsert(entity, data, conflictColumns) {
+        const metadata = this.resolver.resolveEntityMetadata(entity);
+        if (!metadata) {
+            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
         }
-        catch (e) {
-            try {
-                await transactionManager.rollback();
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback transaction: ${rollbackError}`);
-            }
-            throw e;
+        if (!this.driver) {
+            throw new Error("Driver is not initialized.");
         }
-        finally {
-            try {
-                await transactionManager.close();
-            }
-            catch (closeError) {
-                this.logger.error(`Failed to close transaction: ${closeError}`);
+        const pkColumns = metadata.columns
+            .filter((col) => col.options?.primary)
+            .map((col) => col.name);
+        const resolvedConflictColumns = conflictColumns ?? pkColumns;
+        if (resolvedConflictColumns.length === 0) {
+            throw new PrimaryKeyNotFoundError_1.PrimaryKeyNotFoundError(entity.name);
+        }
+        const insertableColumns = metadata.columns.filter((col) => {
+            const value = data[col.name];
+            if (col.options?.autoIncrement &&
+                (value === null || value === undefined)) {
+                return false;
             }
+            return value !== undefined;
+        });
+        if (insertableColumns.length === 0) {
+            return;
+        }
+        const conflictSet = new Set(resolvedConflictColumns);
+        const updateColumnNames = insertableColumns
+            .map((col) => col.name)
+            .filter((name) => !conflictSet.has(name));
+        const wrappedColumns = insertableColumns.map((col) => this.wrap(col.name));
+        const wrappedConflict = resolvedConflictColumns.map((name) => this.wrap(name));
+        const wrappedUpdate = updateColumnNames.map((name) => this.wrap(name));
+        const tableName = this.wrap(metadata.name);
+        if (wrappedUpdate.length === 0) {
+            return;
         }
+        await this.executeInTransaction(async (session) => {
+            const columnValues = insertableColumns.map((col) => data[col.name]);
+            const upsertSql = this.buildUpsertQuery(tableName, wrappedColumns, columnValues, wrappedConflict, wrappedUpdate);
+            await session.query(upsertSql);
+        });
     }
-    async cascadeSaveOneToMany(entity, item, savedParentId) {
-        const oneToManyMeta = this.resolveOneToManyMetadata(entity);
-        for (const rel of oneToManyMeta) {
-            const children = item[rel.propertyKey];
-            if (!children || !Array.isArray(children) || children.length === 0)
-                continue;
-            const RelatedEntity = rel.getRelatedEntity();
-            if (!(0, CascadeType_1.hasCascade)(rel.cascade, "insert") &&
-                !(0, CascadeType_1.hasCascade)(rel.cascade, "update"))
-                continue;
-            const manyToOneItems = this.resolveManyToOneMetadata(RelatedEntity);
-            const matchingRelation = manyToOneItems.find((m) => m.columnName === rel.mappedBy);
-            const fkColumn = matchingRelation?.joinColumn ?? rel.mappedBy;
-            for (const child of children) {
-                child[fkColumn] = savedParentId;
-                await this.save(RelatedEntity, child);
-            }
+    buildUpsertQuery(tableName, columns, values, conflictColumns, updateColumns) {
+        const columnList = (0, sql_template_tag_1.join)(columns.map((c) => (0, sql_template_tag_1.raw)(c)), ", ");
+        const valueList = (0, sql_template_tag_1.join)(values, ", ");
+        if (this.isMySqlFamily()) {
+            const updateSet = (0, sql_template_tag_1.join)(updateColumns.map((col) => (0, sql_template_tag_1.raw)(`${col} = VALUES(${col})`)), ", ");
+            return (0, sql_template_tag_1.default) `INSERT INTO ${(0, sql_template_tag_1.raw)(tableName)} (${columnList}) VALUES (${valueList}) ON DUPLICATE KEY UPDATE ${updateSet}`;
+        }
+        const conflictList = (0, sql_template_tag_1.join)(conflictColumns.map((c) => (0, sql_template_tag_1.raw)(c)), ", ");
+        if (this.isPostgres()) {
+            const updateSet = (0, sql_template_tag_1.join)(updateColumns.map((col) => (0, sql_template_tag_1.raw)(`${col} = EXCLUDED.${col}`)), ", ");
+            return (0, sql_template_tag_1.default) `INSERT INTO ${(0, sql_template_tag_1.raw)(tableName)} (${columnList}) VALUES (${valueList}) ON CONFLICT (${conflictList}) DO UPDATE SET ${updateSet}`;
+        }
+        if ((this.dbType ?? this.client.type) === "sqlite") {
+            const updateSet = (0, sql_template_tag_1.join)(updateColumns.map((col) => (0, sql_template_tag_1.raw)(`${col} = excluded.${col}`)), ", ");
+            return (0, sql_template_tag_1.default) `INSERT INTO ${(0, sql_template_tag_1.raw)(tableName)} (${columnList}) VALUES (${valueList}) ON CONFLICT (${conflictList}) DO UPDATE SET ${updateSet}`;
         }
+        throw new Error(`Unsupported database type for upsert: ${this.dbType}`);
     }
-    async cascadeSaveManyToOne(entity, item) {
-        const manyToOneRelations = this.resolveManyToOneMetadata(entity);
-        for (const rel of manyToOneRelations) {
-            const relatedValue = item[rel.columnName];
-            if (!relatedValue || typeof relatedValue !== "object")
-                continue;
-            if (!(0, CascadeType_1.hasCascade)(rel.option?.cascade, "insert") &&
-                !(0, CascadeType_1.hasCascade)(rel.option?.cascade, "update"))
-                continue;
-            const RelatedEntity = rel.getMappingEntity();
-            const saved = await this.save(RelatedEntity, relatedValue);
-            const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
-            if (relatedMetadata) {
-                const relatedPk = relatedMetadata.columns.find((col) => col.options?.primary);
-                if (relatedPk && rel.joinColumn) {
-                    item[rel.joinColumn] = saved[relatedPk.name];
-                }
-            }
+    async count(entity, where) {
+        return this.aggregateHandler.count(entity, where);
+    }
+    async sum(entity, field, where) {
+        return this.aggregateHandler.sum(entity, field, where);
+    }
+    async avg(entity, field, where) {
+        return this.aggregateHandler.avg(entity, field, where);
+    }
+    async min(entity, field, where) {
+        return this.aggregateHandler.min(entity, field, where);
+    }
+    async max(entity, field, where) {
+        return this.aggregateHandler.max(entity, field, where);
+    }
+    async explain(entity, findOption = {}) {
+        return this.explainHandler.explain(entity, findOption);
+    }
+    wrap(columnName) {
+        if (this.driver && "wrap" in this.driver) {
+            return this.driver.wrap(columnName);
+        }
+        if (this.isPostgres()) {
+            return `"${columnName.replace(/"/g, '""')}"`;
         }
+        return `\`${columnName.replace(/`/g, "``")}\``;
     }
-    async cascadeDeleteOneToMany(entity, criteria) {
-        const oneToManyMeta = this.resolveOneToManyMetadata(entity);
-        for (const rel of oneToManyMeta) {
-            if (!(0, CascadeType_1.hasCascade)(rel.cascade, "delete"))
-                continue;
-            const RelatedEntity = rel.getRelatedEntity();
-            const parentMetadata = this.resolveEntityMetadata(entity);
-            if (!parentMetadata)
-                continue;
-            const pk = parentMetadata.columns.find((col) => col.options?.primary);
-            if (!pk)
-                continue;
-            const parents = await this.find(entity, {
-                where: criteria,
-            });
-            if (!parents)
-                continue;
-            const parentArray = Array.isArray(parents) ? parents : [parents];
-            const manyToOneItems = this.resolveManyToOneMetadata(RelatedEntity);
-            const matchingRelation = manyToOneItems.find((m) => m.columnName === rel.mappedBy);
-            const fkColumn = matchingRelation?.joinColumn ?? rel.mappedBy;
-            for (const parent of parentArray) {
-                const parentId = parent[pk.name];
-                if (parentId === undefined || parentId === null)
-                    continue;
-                await this.delete(RelatedEntity, {
-                    [fkColumn]: parentId,
-                });
-            }
+    isMySqlFamily() {
+        const t = this.dbType ?? this.client.type;
+        return ["mysql", "mariadb"].includes(t);
+    }
+    isPostgres() {
+        const t = this.dbType ?? this.client.type;
+        return t === "postgres";
+    }
+    isSqlite() {
+        const t = this.dbType ?? this.client.type;
+        return t === "sqlite";
+    }
+    warnIfNonSortablePk(entityName, pk) {
+        const pkType = pk.options?.type;
+        const numericTypes = new Set([
+            "int", "number", "float", "double", "bigint",
+        ]);
+        if (!pkType || numericTypes.has(pkType)) {
+            return;
+        }
+        const key = entityName;
+        if (this.cursorPkWarned.has(key)) {
+            return;
+        }
+        this.cursorPkWarned.add(key);
+        const base = `[CursorPagination] '${entityName}' entity uses a non-numeric PK ` +
+            `(type: ${pkType}). Cursor pagination defaults to PK ordering, ` +
+            `which may not reflect insertion order for random values like UUID v4.`;
+        if (this.isMySqlFamily()) {
+            this.logger.warn(`${base} MySQL stores UUIDs as VARCHAR — lexicographic ordering ` +
+                `does not match time-based ordering. Consider specifying ` +
+                `orderBy: "createdAt" or using a sequential ID.`);
+        }
+        else if (this.isPostgres()) {
+            this.logger.warn(`${base} PostgreSQL compares UUID values lexicographically. ` +
+                `For time-ordered pagination, use UUID v7 (sortable) or specify ` +
+                `orderBy: "createdAt".`);
+        }
+        else if (this.isSqlite()) {
+            this.logger.warn(`${base} SQLite compares TEXT values lexicographically. ` +
+                `Consider specifying orderBy: "createdAt" or using an INTEGER PK.`);
+        }
+        else {
+            this.logger.warn(`${base} Consider specifying an explicit orderBy column ` +
+                `(e.g. orderBy: "createdAt") for meaningful pagination order.`);
         }
     }
-    async aggregate(entity, fn, field, where) {
-        const metadata = this.resolveEntityMetadata(entity);
-        if (!metadata) {
-            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
+    async executeInTransaction(fn, existingSession, readNodeOverride) {
+        const reusable = existingSession ?? Transactional_1.transactionStorage.getStore();
+        if (reusable) {
+            return fn(reusable);
         }
-        const transactionManager = new TransactionSessionManager_1.TransactionSessionManager();
+        const session = new TransactionSessionManager_1.TransactionSessionManager();
         try {
-            await transactionManager.connect();
-            await transactionManager.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionManager.query("SET autocommit = 0");
-            }
-            const tableName = metadata.name;
-            const selectExpr = (0, sql_template_tag_1.raw)(`${fn}(${field === "*" ? "*" : this.wrap(field)})`);
-            const whereMap = [];
-            if (where) {
-                for (const key in where) {
-                    const value = where[key];
-                    if (value !== undefined && value !== null) {
-                        whereMap.push(Conditions_1.Conditions.equals(this.wrap(key), value));
-                    }
-                }
-            }
-            let queryStr;
-            if (whereMap.length > 0) {
-                const whereSql = (0, sql_template_tag_1.join)(whereMap, " AND ");
-                queryStr = (0, sql_template_tag_1.default) `SELECT ${selectExpr} AS ${(0, sql_template_tag_1.raw)(this.wrap("result"))} FROM ${(0, sql_template_tag_1.raw)(this.wrap(tableName))} WHERE ${whereSql}`;
+            if (readNodeOverride) {
+                await session.connectToNode(readNodeOverride);
             }
             else {
-                queryStr = (0, sql_template_tag_1.default) `SELECT ${selectExpr} AS ${(0, sql_template_tag_1.raw)(this.wrap("result"))} FROM ${(0, sql_template_tag_1.raw)(this.wrap(tableName))}`;
+                await session.connect();
             }
-            const queryResult = (await transactionManager.query(queryStr));
-            await transactionManager.commit();
-            const { results } = queryResult;
-            if (!results || results.length === 0)
-                return 0;
-            const row = results[0];
-            const value = row.result ?? row["result"];
-            return value === null || value === undefined ? 0 : Number(value);
+            await session.startTransaction();
+            if (this.isMySqlFamily()) {
+                await session.query("SET autocommit = 0");
+            }
+            const result = await fn(session);
+            await session.commit();
+            return result;
         }
         catch (e) {
             try {
-                await transactionManager.rollback();
+                await session.rollback();
             }
             catch (rollbackError) {
                 this.logger.error(`Failed to rollback transaction: ${rollbackError}`);
@@ -2251,43 +1302,27 @@ class EntityManager {
         }
         finally {
             try {
-                await transactionManager.close();
+                await session.close();
             }
             catch (closeError) {
                 this.logger.error(`Failed to close transaction: ${closeError}`);
             }
         }
     }
-    async count(entity, where) {
-        return this.aggregate(entity, "COUNT", "*", where);
-    }
-    async findAndCount(entity, findOption = {}) {
-        const [entities, totalCount] = await Promise.all([
-            this.find(entity, findOption),
-            this.count(entity, findOption.where),
-        ]);
-        return [entities, totalCount];
-    }
-    async sum(entity, field, where) {
-        return this.aggregate(entity, "SUM", field, where);
-    }
-    async avg(entity, field, where) {
-        return this.aggregate(entity, "AVG", field, where);
-    }
-    async min(entity, field, where) {
-        return this.aggregate(entity, "MIN", field, where);
-    }
-    async max(entity, field, where) {
-        return this.aggregate(entity, "MAX", field, where);
+    resolveSelectColumns(select) {
+        if (Array.isArray(select)) {
+            return select.map((col) => String(col));
+        }
+        const columns = [];
+        for (const key in select) {
+            if (select[key] === true) {
+                columns.push(key);
+            }
+        }
+        return columns;
     }
     async query(sqlQuery, params) {
-        const transactionHolder = new TransactionSessionManager_1.TransactionSessionManager();
-        try {
-            await transactionHolder.connect();
-            await transactionHolder.startTransaction();
-            if (this.isMySqlFamily()) {
-                await transactionHolder.query("SET autocommit = 0");
-            }
+        return this.executeInTransaction(async (session) => {
             let queryResult;
             if (typeof sqlQuery === "string") {
                 if (params && params.length > 0) {
@@ -2297,16 +1332,15 @@ class EntityManager {
                         values: params,
                         strings: [sqlQuery],
                     };
-                    queryResult = await transactionHolder.query(parameterizedSql);
+                    queryResult = await session.query(parameterizedSql);
                 }
                 else {
-                    queryResult = await transactionHolder.query(sqlQuery);
+                    queryResult = await session.query(sqlQuery);
                 }
             }
             else {
-                queryResult = await transactionHolder.query(sqlQuery);
+                queryResult = await session.query(sqlQuery);
             }
-            await transactionHolder.commit();
             if (queryResult?.results) {
                 return queryResult.results ?? [];
             }
@@ -2314,24 +1348,7 @@ class EntityManager {
                 return queryResult;
             }
             return [];
-        }
-        catch (e) {
-            try {
-                await transactionHolder.rollback();
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback raw query transaction: ${rollbackError}`);
-            }
-            throw e;
-        }
-        finally {
-            try {
-                await transactionHolder.close();
-            }
-            catch (closeError) {
-                this.logger.error(`Failed to close raw query transaction: ${closeError}`);
-            }
-        }
+        });
     }
     getRepository(entity) {
         return BaseRepository_1.BaseRepository.of(entity, this);