@stingerloom/orm 0.1.0

package/dist/core/EntityManager.js

@@ -0,0 +1,2347 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        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 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");
+class EntityManager {
+    constructor() {
+        this._entities = [];
+        this.logger = new utils_1.Logger(EntityManager.name);
+        this.dirtyEntities = new Set();
+        this.eventEmitter = new EntityEventEmitter_1.EntityEventEmitter();
+        this.subscribers = [];
+        this.queryTracker = null;
+        this.replicationRouter = null;
+        this.connectionName = "default";
+    }
+    async register(databaseClientOptions, connectionName = "default") {
+        await this.connect(databaseClientOptions, connectionName);
+        await this.registerEntities();
+    }
+    get client() {
+        return DatabaseClient_1.DatabaseClient.getInstance();
+    }
+    get connection() {
+        const c = this.client;
+        if (typeof c.getConnection === "function") {
+            return c.getConnection(this.connectionName);
+        }
+        return c.getConnection();
+    }
+    getConnectionName() {
+        return this.connectionName;
+    }
+    async connect(databaseClientOptions, connectionName = "default") {
+        this.connectionName = connectionName;
+        const client = this.client;
+        const connector = await client.connect(databaseClientOptions, connectionName);
+        const { schema, queryTimeout, replication } = databaseClientOptions;
+        const dbType = (typeof client.getType === "function"
+            ? client.getType(connectionName)
+            : client.type);
+        this.dbType = dbType;
+        switch (dbType) {
+            case "mariadb":
+            case "mysql":
+                this.driver = new MySqlDriver_1.MySqlDriver(connector, dbType);
+                this.dataSource = new MySqlDataSource_1.MySqlDataSource(connector);
+                break;
+            case "postgres":
+                this.driver = new PostgresDriver_1.PostgresDriver(connector, dbType, schema);
+                this.dataSource = new PostgresDataSource_1.PostgresDataSource(connector);
+                break;
+            case "sqlite":
+                this.driver = new SqliteDriver_1.SqliteDriver(connector);
+                this.dataSource = new SqliteDataSource_1.SqliteDataSource(connector);
+                break;
+            default:
+                throw new NotSupportedDatabaseTypeError_1.NotSupportedDatabaseTypeError();
+        }
+        this.initQueryTracker(databaseClientOptions);
+        const isTimeoutSupported = queryTimeout && queryTimeout > 0;
+        if (isTimeoutSupported) {
+            this.defaultQueryTimeout = queryTimeout;
+        }
+        if (replication) {
+            this.replicationRouter = new ReplicationRouter_1.ReplicationRouter(replication);
+        }
+    }
+    initQueryTracker(options) {
+        const logging = options.logging;
+        if (typeof logging === "object" && logging !== null) {
+            const loggingOpts = logging;
+            if (loggingOpts.enableQueryTracking === false) {
+                this.queryTracker = null;
+                return;
+            }
+            if (loggingOpts.nPlusOne || loggingOpts.slowQueryMs) {
+                this.queryTracker = new QueryTracker_1.QueryTracker({
+                    slowQueryMs: loggingOpts.slowQueryMs ?? null,
+                    enabled: loggingOpts.enableQueryTracking ?? true,
+                    maxLogEntries: loggingOpts.maxLogEntries,
+                    ttlMs: loggingOpts.ttlMs,
+                });
+            }
+        }
+    }
+    getQueryLog() {
+        return this.queryTracker?.getLog() ?? [];
+    }
+    getQueryTracker() {
+        return this.queryTracker;
+    }
+    beginTrackQuery() {
+        this.queryTracker?.beginQuery();
+    }
+    trackQuery(entityName, sqlText, durationMs) {
+        this.queryTracker?.endQuery();
+        this.queryTracker?.track(entityName, sqlText, durationMs);
+    }
+    getReadNode(useMaster) {
+        if (!this.replicationRouter)
+            return null;
+        if (useMaster)
+            return this.replicationRouter.getWriteNode();
+        return this.replicationRouter.getReadNode();
+    }
+    getWriteNode() {
+        if (!this.replicationRouter)
+            return null;
+        return this.replicationRouter.getWriteNode();
+    }
+    get isReplicationEnabled() {
+        return this.replicationRouter !== null;
+    }
+    getReplicationRouter() {
+        return this.replicationRouter;
+    }
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+    }
+    removeAllListeners() {
+        this.eventEmitter.removeAllListeners();
+    }
+    addSubscriber(subscriber) {
+        this.subscribers.push(subscriber);
+    }
+    removeSubscriber(subscriber) {
+        const idx = this.subscribers.indexOf(subscriber);
+        if (idx !== -1) {
+            this.subscribers.splice(idx, 1);
+        }
+    }
+    async notifySubscribers(entityClass, method, arg) {
+        for (const sub of this.subscribers) {
+            if (sub.listenTo() === entityClass && typeof sub[method] === "function") {
+                await sub[method](arg);
+            }
+        }
+    }
+    async notifyTransactionSubscribers(method) {
+        for (const sub of this.subscribers) {
+            if (typeof sub[method] === "function") {
+                await sub[method]();
+            }
+        }
+    }
+    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 });
+        if (result === undefined || result === null) {
+            return null;
+        }
+        if (Array.isArray(result)) {
+            return result[0] ?? null;
+        }
+        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 = {}) {
+        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);
+            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 rel of eagerRelations) {
+                const RelatedEntity = rel.getMappingEntity();
+                const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
+                if (!relatedMetadata)
+                    continue;
+                const relatedName = relatedMetadata.name || RelatedEntity.name;
+                for (const col of relatedMetadata.columns) {
+                    const alias = `${rel.columnName}_${col.name}`;
+                    selectMap.push(`${this.wrap(relatedName)}.${this.wrap(col.name)} AS ${this.wrap(alias)}`);
+                }
+            }
+            for (const rel of eagerOneToOneRelations) {
+                const RelatedEntity = rel.getRelatedEntity();
+                const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
+                if (!relatedMetadata)
+                    continue;
+                const relatedName = relatedMetadata.name || RelatedEntity.name;
+                for (const col of relatedMetadata.columns) {
+                    const alias = `${rel.propertyKey}_${col.name}`;
+                    selectMap.push(`${this.wrap(relatedName)}.${this.wrap(col.name)} AS ${this.wrap(alias)}`);
+                }
+            }
+            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));
+            for (const rel of eagerRelations) {
+                const RelatedEntity = rel.getMappingEntity();
+                const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
+                if (!relatedMetadata)
+                    continue;
+                const relatedTableName = relatedMetadata.name || RelatedEntity.name;
+                const joinColumn = rel.joinColumn ?? rel.columnName;
+                const relatedPk = relatedMetadata.columns.find((col) => col.options?.primary);
+                if (!relatedPk)
+                    continue;
+                const joinCondition = (0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(tableName))}.${(0, sql_template_tag_1.raw)(this.wrap(joinColumn))} = ${(0, sql_template_tag_1.raw)(this.wrap(relatedTableName))}.${(0, sql_template_tag_1.raw)(this.wrap(relatedPk.name))}`;
+                qb.leftJoin(this.wrap(relatedTableName), this.wrap(relatedTableName), joinCondition);
+            }
+            for (const rel of eagerOneToOneRelations) {
+                const RelatedEntity = rel.getRelatedEntity();
+                const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
+                if (!relatedMetadata)
+                    continue;
+                const relatedTableName = relatedMetadata.name || RelatedEntity.name;
+                const joinColumn = rel.joinColumn;
+                const relatedPk = relatedMetadata.columns.find((col) => col.options?.primary);
+                if (!relatedPk)
+                    continue;
+                const joinCondition = (0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(tableName))}.${(0, sql_template_tag_1.raw)(this.wrap(joinColumn))} = ${(0, sql_template_tag_1.raw)(this.wrap(relatedTableName))}.${(0, sql_template_tag_1.raw)(this.wrap(relatedPk.name))}`;
+                qb.leftJoin(this.wrap(relatedTableName), this.wrap(relatedTableName), joinCondition);
+            }
+            qb.where(whereMap);
+            if (groupBy && groupBy.length > 0) {
+                const groupByColumns = groupBy.map((col) => hasEagerJoins
+                    ? `${this.wrap(tableName)}.${this.wrap(col)}`
+                    : this.wrap(col));
+                qb.groupBy(groupByColumns);
+            }
+            if (having && having.length > 0) {
+                qb.having(having);
+            }
+            qb.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 resultQuery = qb.build();
+            const effectiveTimeout = findOption.timeout ?? this.defaultQueryTimeout;
+            if (effectiveTimeout && effectiveTimeout > 0 && this.driver) {
+                const timeoutSql = this.driver.setQueryTimeout(effectiveTimeout);
+                await transactionHolder.query(timeoutSql);
+            }
+            const queryStartTime = Date.now();
+            this.beginTrackQuery();
+            const queryResult = (await transactionHolder.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;
+            }
+            const isEntityArray = results.length > 1;
+            let entityResult;
+            if (hasEagerJoins) {
+                entityResult = resultTransformer.transformNested(entity, queryResult);
+            }
+            else if (isEntityArray) {
+                entityResult = resultTransformer.toEntities(entity, queryResult);
+            }
+            else {
+                entityResult = resultTransformer.toEntity(entity, queryResult);
+            }
+            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);
+            }
+            const lazyRelations = manyToOneRelations.filter((rel) => {
+                return rel.option?.lazy === true && rel.option?.eager !== true;
+            });
+            if (lazyRelations.length > 0 && entityResult) {
+                const entities = Array.isArray(entityResult)
+                    ? entityResult
+                    : [entityResult];
+                for (const rel of lazyRelations) {
+                    const joinColumn = rel.joinColumn ?? rel.columnName;
+                    const RelatedEntity = rel.getMappingEntity();
+                    for (const item of entities) {
+                        const fkValue = item[joinColumn];
+                        if (fkValue === undefined || fkValue === null)
+                            continue;
+                        const relatedMetadata = this.resolveEntityMetadata(RelatedEntity);
+                        if (!relatedMetadata)
+                            continue;
+                        const relatedPk = relatedMetadata.columns.find((col) => col.options?.primary);
+                        if (!relatedPk)
+                            continue;
+                        const em = this;
+                        (0, LazyLoader_1.injectLazyProxy)(item, rel.columnName, async () => {
+                            const result = await em.findOne(RelatedEntity, {
+                                where: { [relatedPk.name]: fkValue },
+                            });
+                            return result;
+                        });
+                    }
+                }
+            }
+            return entityResult;
+        }
+        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}`);
+            }
+        }
+    }
+    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;
+    }
+    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);
+    }
+    isPostgres() {
+        const t = this.dbType ?? this.client.type;
+        return t === "postgres";
+    }
+    async save(entity, item) {
+        const metadata = this.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");
+            }
+            const pkColumns = metadata.columns.filter((column) => column.options?.primary);
+            const pk = pkColumns[0];
+            const hasAutoIncrementPk = pkColumns.some((col) => col.options?.autoIncrement);
+            const primaryKeyValue = pk ? item[pk.name] : undefined;
+            const isInsert = hasAutoIncrementPk
+                ? !primaryKeyValue
+                : true;
+            const buildPkWhere = (pkValues) => {
+                return pkColumns.map((col) => {
+                    const value = pkValues
+                        ? pkValues[col.name]
+                        : item[col.name];
+                    return (0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(col.name))} = ${value}`;
+                });
+            };
+            const buildPkFindWhere = (pkValues) => {
+                const where = {};
+                for (const col of pkColumns) {
+                    where[col.name] = pkValues
+                        ? pkValues[col.name]
+                        : item[col.name];
+                }
+                return where;
+            };
+            if (isInsert) {
+                await this.runHooks(entity, item, "beforeInsert");
+                await this.eventEmitter.emit("beforeInsert", { entity, data: item });
+                await this.notifySubscribers(entity, "beforeInsert", {
+                    entity: item,
+                    manager: this,
+                });
+                const insertableColumns = metadata.columns.filter((column) => {
+                    const isAutoIncrement = column.options?.autoIncrement;
+                    const value = item[column.name];
+                    if (isAutoIncrement && (value === null || value === undefined)) {
+                        return false;
+                    }
+                    return true;
+                });
+                const columns = insertableColumns.map((column) => {
+                    return (0, sql_template_tag_1.raw)(this.wrap(column.name));
+                });
+                const values = insertableColumns.map((column) => {
+                    return item[column.name];
+                });
+                const manyToOneRelations = this.resolveManyToOneMetadata(entity);
+                for (const rel of manyToOneRelations) {
+                    if (!rel.joinColumn)
+                        continue;
+                    const relatedValue = item[rel.columnName];
+                    const idPropValue = item[`${rel.columnName}Id`];
+                    const existingIdx = insertableColumns.findIndex((col) => col.name === rel.joinColumn);
+                    let fkValue = undefined;
+                    if (relatedValue === null) {
+                        fkValue = null;
+                    }
+                    else if (relatedValue && typeof relatedValue === "object") {
+                        const RelatedEntity = rel.getMappingEntity();
+                        const relatedMeta = this.resolveEntityMetadata(RelatedEntity);
+                        if (relatedMeta) {
+                            const relatedPk = relatedMeta.columns.find((col) => col.options?.primary);
+                            if (relatedPk) {
+                                fkValue = relatedValue[relatedPk.name] ?? undefined;
+                            }
+                        }
+                    }
+                    else if (idPropValue != null) {
+                        fkValue = idPropValue;
+                    }
+                    if (fkValue !== undefined) {
+                        if (existingIdx >= 0) {
+                            values[existingIdx] = fkValue;
+                        }
+                        else {
+                            columns.push((0, sql_template_tag_1.raw)(this.wrap(rel.joinColumn)));
+                            values.push(fkValue);
+                        }
+                    }
+                }
+                const isPostgres = this.isPostgres();
+                const returningCols = pkColumns
+                    .map((col) => this.wrap(col.name))
+                    .join(", ");
+                const returningSql = isPostgres
+                    ? (0, sql_template_tag_1.raw)(` RETURNING ${returningCols}`)
+                    : (0, sql_template_tag_1.raw)("");
+                const insertSql = (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)(values, ", ")})${returningSql}
+                    `;
+                const saveQueryStart = Date.now();
+                this.beginTrackQuery();
+                const queryResult = (await transactionManager.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, {
+                        where: findWhere,
+                    });
+                    const cascadeId = hasAutoIncrementPk
+                        ? queryResult?.results?.insertId
+                        : primaryKeyValue;
+                    await this.cascadeSaveOneToMany(entity, item, cascadeId);
+                    await this.runHooks(entity, item, "afterInsert");
+                    await this.eventEmitter.emit("afterInsert", { entity, data: item });
+                    await this.notifySubscribers(entity, "afterInsert", {
+                        entity: item,
+                        manager: this,
+                    });
+                    return result;
+                }
+                if (isPostgres && queryResult?.results?.length > 0) {
+                    const returnedRow = queryResult.results[0];
+                    const findWhere = buildPkFindWhere(returnedRow);
+                    const result = await this.findOne(entity, {
+                        where: findWhere,
+                    });
+                    const cascadeId = returnedRow[pk.name];
+                    await this.cascadeSaveOneToMany(entity, item, cascadeId);
+                    await this.runHooks(entity, item, "afterInsert");
+                    await this.eventEmitter.emit("afterInsert", { entity, data: item });
+                    await this.notifySubscribers(entity, "afterInsert", {
+                        entity: item,
+                        manager: this,
+                    });
+                    return result;
+                }
+                await this.runHooks(entity, item, "afterInsert");
+                await this.eventEmitter.emit("afterInsert", { entity, data: item });
+                await this.notifySubscribers(entity, "afterInsert", {
+                    entity: item,
+                    manager: this,
+                });
+                return queryResult;
+            }
+            await this.runHooks(entity, item, "beforeUpdate");
+            await this.eventEmitter.emit("beforeUpdate", { entity, data: item });
+            await this.notifySubscribers(entity, "beforeUpdate", {
+                entity: item,
+                manager: this,
+            });
+            const pkColumnNames = new Set(pkColumns.map((col) => col.name));
+            const updatableColumns = metadata.columns.filter((column) => {
+                if (pkColumnNames.has(column.name))
+                    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 updatedColumnNames = new Set(updatableColumns.map((col) => col.name));
+            const updateManyToOneRelations = this.resolveManyToOneMetadata(entity);
+            for (const rel of updateManyToOneRelations) {
+                if (!rel.joinColumn)
+                    continue;
+                const relatedValue = item[rel.columnName];
+                if (relatedValue === undefined)
+                    continue;
+                const alreadyInSet = updatedColumnNames.has(rel.joinColumn);
+                if (relatedValue === null) {
+                    if (alreadyInSet) {
+                        const existingIdx = updatableColumns.findIndex((col) => col.name === rel.joinColumn);
+                        updateMap[existingIdx] =
+                            (0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(rel.joinColumn))} = ${null}`;
+                    }
+                    else {
+                        updateMap.push((0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(rel.joinColumn))} = ${null}`);
+                        updatedColumnNames.add(rel.joinColumn);
+                    }
+                }
+                else if (typeof relatedValue === "object") {
+                    const RelatedEntity = rel.getMappingEntity();
+                    const relatedMeta = this.resolveEntityMetadata(RelatedEntity);
+                    if (relatedMeta) {
+                        const relatedPk = relatedMeta.columns.find((col) => col.options?.primary);
+                        if (relatedPk) {
+                            const fkValue = relatedValue[relatedPk.name];
+                            if (fkValue !== undefined && fkValue !== null) {
+                                if (alreadyInSet) {
+                                    const existingIdx = updatableColumns.findIndex((col) => col.name === rel.joinColumn);
+                                    updateMap[existingIdx] =
+                                        (0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(rel.joinColumn))} = ${fkValue}`;
+                                }
+                                else {
+                                    updateMap.push((0, sql_template_tag_1.default) `${(0, sql_template_tag_1.raw)(this.wrap(rel.joinColumn))} = ${fkValue}`);
+                                    updatedColumnNames.add(rel.joinColumn);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            const pkWhereClauses = buildPkWhere();
+            if (updateMap.length > 0) {
+                const updateSql = (0, sql_template_tag_1.default) `
+            UPDATE ${(0, sql_template_tag_1.raw)(this.wrap(metadata.name))}
+            SET ${(0, sql_template_tag_1.join)(updateMap, ", ")}
+            WHERE ${(0, sql_template_tag_1.join)(pkWhereClauses, " AND ")}
+                  `;
+                const updateStart = Date.now();
+                this.beginTrackQuery();
+                await transactionManager.query(updateSql);
+                this.trackQuery(entity.name, updateSql.text ?? String(updateSql), Date.now() - updateStart);
+            }
+            await transactionManager.commit();
+            await this.cascadeSaveOneToMany(entity, item, primaryKeyValue);
+            await this.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, {
+                where: buildPkFindWhere(),
+            });
+            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}`);
+            }
+        }
+    }
+    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;
+    }
+    async insertMany(entity, items) {
+        if (items.length === 0) {
+            return { affected: 0 };
+        }
+        const metadata = this.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);
+            const timestampTypes = new Set(["datetime", "timestamp", "date"]);
+            const timestampColumns = metadata.columns.filter((col) => col.options?.type &&
+                timestampTypes.has(col.options.type) &&
+                col.name !== deletedAtColumn);
+            if (timestampColumns.length > 0) {
+                const now = new Date();
+                for (const item of items) {
+                    for (const col of timestampColumns) {
+                        if (item[col.name] == null) {
+                            item[col.name] = now;
+                        }
+                    }
+                }
+            }
+            const insertableColumns = metadata.columns.filter((column) => {
+                const isAutoIncrement = column.options?.autoIncrement;
+                if (!isAutoIncrement)
+                    return true;
+                return items.every((item) => item[column.name] !== null &&
+                    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 fkColumns = [];
+            for (const rel of manyToOneRelations) {
+                if (!rel.joinColumn)
+                    continue;
+                const alreadyIncluded = insertableColumns.some((col) => col.name === rel.joinColumn);
+                if (!alreadyIncluded) {
+                    columns.push((0, sql_template_tag_1.raw)(this.wrap(rel.joinColumn)));
+                    fkColumns.push({
+                        joinColumn: rel.joinColumn,
+                        propertyName: rel.columnName,
+                        relMeta: rel,
+                    });
+                }
+            }
+            const valueRows = items.map((item) => {
+                const rowValues = insertableColumns.map((column) => item[column.name]);
+                for (const fk of fkColumns) {
+                    const relatedValue = item[fk.propertyName];
+                    const idPropValue = item[`${fk.propertyName}Id`];
+                    if (relatedValue != null) {
+                        if (typeof relatedValue === "object") {
+                            const RelatedEntity = fk.relMeta.getMappingEntity();
+                            const relatedMeta = this.resolveEntityMetadata(RelatedEntity);
+                            const relatedPk = relatedMeta?.columns.find((col) => col.options?.primary);
+                            rowValues.push(relatedPk ? relatedValue[relatedPk.name] ?? null : null);
+                        }
+                        else {
+                            rowValues.push(relatedValue);
+                        }
+                    }
+                    else if (idPropValue != null) {
+                        rowValues.push(idPropValue);
+                    }
+                    else {
+                        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();
+            }
+            catch (closeError) {
+                this.logger.error(`Failed to close transaction: ${closeError}`);
+            }
+        }
+    }
+    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 delete(entity, criteria) {
+        const metadata = this.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");
+            await this.eventEmitter.emit("beforeDelete", { entity, data: criteria });
+            await this.notifySubscribers(entity, "beforeDelete", {
+                entityClass: entity,
+                criteria,
+                manager: this,
+            });
+            await this.cascadeDeleteOneToMany(entity, criteria);
+            const whereMap = [];
+            for (const key in criteria) {
+                const value = criteria[key];
+                if (value !== undefined && value !== null) {
+                    whereMap.push(Conditions_1.Conditions.equals(this.wrap(key), value));
+                }
+            }
+            if (whereMap.length === 0) {
+                throw new DeleteWithoutConditionsError_1.DeleteWithoutConditionsError("Delete");
+            }
+            const whereSql = (0, sql_template_tag_1.join)(whereMap, " AND ");
+            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));
+            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;
+            }
+            else {
+                affected = queryResult?.rowCount ?? 0;
+            }
+            await this.runHooks(entity, criteria, "afterDelete");
+            await this.eventEmitter.emit("afterDelete", { entity, data: criteria });
+            await this.notifySubscribers(entity, "afterDelete", {
+                entityClass: entity,
+                criteria,
+                manager: this,
+            });
+            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 clear(entity) {
+        const metadata = this.resolveEntityMetadata(entity);
+        if (!metadata) {
+            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
+        }
+        if (!this.driver) {
+            throw new Error("Driver is not initialized. Call connect() first.");
+        }
+        await this.driver.clear(metadata.name);
+    }
+    async softDelete(entity, criteria) {
+        const metadata = this.resolveEntityMetadata(entity);
+        if (!metadata) {
+            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
+        }
+        const deletedAtColumn = this.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");
+            }
+            const whereMap = [];
+            for (const key in criteria) {
+                const value = criteria[key];
+                if (value !== undefined && value !== null) {
+                    whereMap.push(Conditions_1.Conditions.equals(this.wrap(key), value));
+                }
+            }
+            if (whereMap.length === 0) {
+                throw new DeleteWithoutConditionsError_1.DeleteWithoutConditionsError("Soft delete");
+            }
+            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();
+            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}`);
+            }
+        }
+    }
+    async restore(entity, criteria) {
+        const metadata = this.resolveEntityMetadata(entity);
+        if (!metadata) {
+            throw new EntityMetadataNotFoundError_1.EntityMetadataNotFoundError(entity.name);
+        }
+        const deletedAtColumn = this.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");
+            }
+            const whereMap = [];
+            for (const key in criteria) {
+                const value = criteria[key];
+                if (value !== undefined && value !== null) {
+                    whereMap.push(Conditions_1.Conditions.equals(this.wrap(key), value));
+                }
+            }
+            if (whereMap.length === 0) {
+                throw new DeleteWithoutConditionsError_1.DeleteWithoutConditionsError("Restore");
+            }
+            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();
+            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}`);
+            }
+        }
+    }
+    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);
+            }
+        }
+    }
+    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 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,
+                });
+            }
+        }
+    }
+    async aggregate(entity, fn, field, where) {
+        const metadata = this.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 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}`;
+            }
+            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))}`;
+            }
+            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);
+        }
+        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 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);
+    }
+    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");
+            }
+            let queryResult;
+            if (typeof sqlQuery === "string") {
+                if (params && params.length > 0) {
+                    const parameterizedSql = {
+                        text: sqlQuery,
+                        sql: sqlQuery,
+                        values: params,
+                        strings: [sqlQuery],
+                    };
+                    queryResult = await transactionHolder.query(parameterizedSql);
+                }
+                else {
+                    queryResult = await transactionHolder.query(sqlQuery);
+                }
+            }
+            else {
+                queryResult = await transactionHolder.query(sqlQuery);
+            }
+            await transactionHolder.commit();
+            if (queryResult?.results) {
+                return queryResult.results ?? [];
+            }
+            if (Array.isArray(queryResult)) {
+                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);
+    }
+    async withTenant(tenantId, callback) {
+        return MetadataContext_1.MetadataContext.run(tenantId, () => callback(this));
+    }
+    getDriver() {
+        return this.driver;
+    }
+}
+exports.EntityManager = EntityManager;
+//# sourceMappingURL=EntityManager.js.map