@pangza/orm 0.0.0-stage → 1.0.1

package/dist/BaseMapper.js

@@ -0,0 +1,653 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMapper = void 0;
+const Db_1 = __importDefault(require("./Db"));
+const config_1 = require("./config");
+const entityDecorators_1 = require("./entityDecorators");
+const errors_1 = require("./errors");
+const fill_1 = require("./fill");
+const hydrate_1 = require("./hydrate");
+const identifier_1 = require("./identifier");
+const IdType_1 = require("./IdType");
+const QueryWrapper_1 = require("./QueryWrapper");
+const resultMap_1 = require("./resultMap");
+const security_1 = require("./security");
+/**
+ * 通用 Mapper（对齐 MyBatis-Plus BaseMapper）
+ * 支持逻辑删除、自动填充、乐观锁（均可配置开关）。
+ */
+class BaseMapper {
+    constructor(options) {
+        this.columnNames = null;
+        const global = (0, config_1.getOrmConfig)();
+        const datasource = (options.datasource ?? "default").trim() || "default";
+        this.opts = {
+            table: (0, security_1.assertIdent)(options.table),
+            idField: (0, security_1.assertIdent)(options.idField ?? "id"),
+            datasource,
+            logicDeleteExplicit: options.logicDelete,
+            logicDeleteField: (0, security_1.assertIdent)(options.logicDeleteField ?? global.logicDeleteField),
+            logicDeleteValue: options.logicDeleteValue ?? global.logicDeleteValue,
+            logicNotDeleteValue: options.logicNotDeleteValue ?? global.logicNotDeleteValue,
+            optimisticLockExplicit: options.optimisticLock,
+            versionField: (0, security_1.assertIdent)(options.versionField ?? global.versionField),
+            fill: options.fill ?? true,
+            updateNullStrategy: options.updateNullStrategy ?? "INCLUDE",
+            entity: options.entity,
+        };
+        this.dialect = Db_1.default.getDialect(datasource);
+    }
+    /** 更新字段是否参与 SET（undefined 永不参与；null 受 updateNullStrategy 控制） */
+    shouldWriteUpdateValue(value) {
+        if (value === undefined)
+            return false;
+        if (value === null && this.opts.updateNullStrategy === "IGNORE") {
+            return false;
+        }
+        return true;
+    }
+    async query(sql, params = []) {
+        return Db_1.default.queryOn(this.opts.datasource, sql, params);
+    }
+    async tx(fn) {
+        return Db_1.default.transactionOn(this.opts.datasource, fn);
+    }
+    cfg() {
+        return (0, config_1.getOrmConfig)();
+    }
+    /** 是否启用逻辑删除（表级优先，否则读全局） */
+    isLogicDelete() {
+        return this.opts.logicDeleteExplicit ?? this.cfg().logicDelete;
+    }
+    /** 是否启用乐观锁（表级优先，否则读全局） */
+    isOptimisticLock() {
+        return this.opts.optimisticLockExplicit ?? this.cfg().optimisticLock;
+    }
+    /** 未删除条件（对齐 MyBatis-Plus：字段 = 未删除值） */
+    notDeletedClause() {
+        const col = this.colSql(this.opts.logicDeleteField);
+        return {
+            sql: `${col} = ?`,
+            params: [this.opts.logicNotDeleteValue],
+        };
+    }
+    tableSql() {
+        return this.dialect.quoteIdent(this.opts.table);
+    }
+    idSql() {
+        return this.dialect.quoteIdent(this.opts.idField);
+    }
+    colSql(name) {
+        return this.dialect.quoteIdent((0, security_1.assertIdent)(name));
+    }
+    /**
+     * 把实体属性名映射为列名，并去掉 exist:false 字段，
+     * 避免 createTime / create_time 双键写入 SQL。
+     */
+    normalizeEntityRow(row) {
+        if (!this.opts.entity)
+            return row;
+        const fields = (0, entityDecorators_1.getEntityFields)(this.opts.entity);
+        if (!fields.length)
+            return row;
+        const out = { ...row };
+        for (const f of fields) {
+            if (!f.exist) {
+                delete out[f.property];
+                delete out[f.column];
+                continue;
+            }
+            if (f.property !== f.column &&
+                out[f.property] !== undefined &&
+                out[f.column] === undefined) {
+                out[f.column] = out[f.property];
+            }
+            if (f.property !== f.column) {
+                delete out[f.property];
+            }
+        }
+        return out;
+    }
+    async getColumnNames() {
+        if (this.columnNames)
+            return this.columnNames;
+        const { sql, params } = this.dialect.listColumnsSql(this.opts.table);
+        const rows = (await this.query(sql, params));
+        const names = this.dialect
+            .parseColumnNames(rows)
+            .filter(Boolean);
+        this.columnNames = new Set(names);
+        return this.columnNames;
+    }
+    /** 表上不存在的自动填充字段直接丢掉，避免 Unknown column */
+    async stripMissingFillFields(row) {
+        const cols = await this.getColumnNames();
+        const cfg = this.cfg();
+        for (const field of [
+            cfg.fillCreateTime,
+            cfg.fillUpdateTime,
+            cfg.fillCreateBy,
+            cfg.fillUpdateBy,
+        ]) {
+            if (field && row[field] !== undefined && !cols.has(field)) {
+                delete row[field];
+            }
+        }
+    }
+    async assertLogicDeleteColumn() {
+        if (!this.isLogicDelete())
+            return;
+        const cols = await this.getColumnNames();
+        const field = this.opts.logicDeleteField;
+        if (!cols.has(field)) {
+            throw new Error(`[ORM] 表 ${this.opts.table}（数据源 ${this.opts.datasource}）没有逻辑删除列 ${field}。` +
+                `请 ALTER TABLE 增加该列，或 @Mapper / table(..., { logicDelete: false })。` +
+                `当前表列: ${[...cols].join(", ") || "(空)"}`);
+        }
+    }
+    /** 追加未删除条件（不修改调用方 wrapper） */
+    withLogic(wrapper) {
+        const src = wrapper ?? new QueryWrapper_1.QueryWrapper(this.dialect);
+        if (!this.isLogicDelete() || src.isIgnoreLogicDelete()) {
+            return src;
+        }
+        return src
+            .clone()
+            .eq(this.opts.logicDeleteField, this.opts.logicNotDeleteValue);
+    }
+    hydrateOpts(query) {
+        if (query?.relations === false) {
+            return {
+                datasource: this.opts.datasource,
+                relations: false,
+                properties: [],
+            };
+        }
+        if (Array.isArray(query?.relations)) {
+            return {
+                datasource: this.opts.datasource,
+                relations: query.relations,
+                includeLazy: true,
+                properties: query.relations,
+            };
+        }
+        return { datasource: this.opts.datasource };
+    }
+    normalizeListArgs(wrapperOrOptions, limitOrOptions) {
+        if (wrapperOrOptions &&
+            typeof wrapperOrOptions === "object" &&
+            !(wrapperOrOptions instanceof QueryWrapper_1.QueryWrapper) &&
+            ("relations" in wrapperOrOptions || "limit" in wrapperOrOptions)) {
+            return { options: wrapperOrOptions };
+        }
+        if (typeof limitOrOptions === "number") {
+            return {
+                wrapper: wrapperOrOptions,
+                options: { limit: limitOrOptions },
+            };
+        }
+        return {
+            wrapper: wrapperOrOptions,
+            options: limitOrOptions ?? {},
+        };
+    }
+    /** 按主键查询 */
+    async selectById(id, options) {
+        return this.selectOne(new QueryWrapper_1.QueryWrapper(this.dialect).eq(this.opts.idField, id), options);
+    }
+    /** 条件查询单条 */
+    async selectOne(wrapper, options) {
+        const list = await this.selectList(wrapper, {
+            ...options,
+            limit: options?.limit ?? 1,
+        });
+        return list[0] ?? null;
+    }
+    /** WHERE + GROUP BY + HAVING + ORDER BY + LAST（去多余空格） */
+    fragTail(frag) {
+        return `${frag.whereSql} ${frag.groupSql} ${frag.havingSql} ${frag.orderSql} ${frag.lastSql}`
+            .replace(/\s+/g, " ")
+            .trim();
+    }
+    /** 有 GROUP BY 时用子查询计组数，否则普通 COUNT */
+    countSqlFromFrag(frag) {
+        if (frag.groupSql) {
+            const inner = `${frag.whereSql} ${frag.groupSql} ${frag.havingSql} ${frag.lastSql}`
+                .replace(/\s+/g, " ")
+                .trim();
+            return `SELECT COUNT(1) AS cnt FROM (SELECT 1 FROM ${this.tableSql()} ${inner}) AS _g`;
+        }
+        return `SELECT COUNT(1) AS cnt FROM ${this.tableSql()} ${frag.whereSql} ${frag.lastSql}`
+            .replace(/\s+/g, " ")
+            .trim();
+    }
+    /**
+     * 条件查询列表。
+     * @param limitOrOptions 数字 limit，或 `{ limit, relations }`
+     */
+    async selectList(wrapper, limitOrOptions) {
+        const { wrapper: w, options } = this.normalizeListArgs(wrapper, limitOrOptions);
+        await this.assertLogicDeleteColumn();
+        const frag = this.withLogic(w).build();
+        let sql = `SELECT ${frag.selectSql} FROM ${this.tableSql()} ${this.fragTail(frag)}`.trim();
+        const params = [...frag.params];
+        const limit = options.limit;
+        if (limit != null) {
+            const n = (0, security_1.assertSafeUint)(limit, "limit");
+            const hasOrder = /\bORDER\s+BY\b/i.test(sql);
+            sql = this.dialect.appendLimitOffset(sql, n, 0, hasOrder);
+        }
+        const rows = (0, resultMap_1.mapResultRows)((await this.query(sql, params)));
+        return (0, hydrate_1.hydrateFieldSelects)(this.opts.entity, rows, this.hydrateOpts(options));
+    }
+    /** 条件计数（含 GROUP BY 时返回分组行数） */
+    async selectCount(wrapper) {
+        await this.assertLogicDeleteColumn();
+        const frag = this.withLogic(wrapper).build();
+        const sql = this.countSqlFromFrag(frag);
+        const rows = await this.query(sql, frag.params);
+        return Number(rows[0]?.cnt ?? rows[0]?.CNT ?? 0);
+    }
+    /** 分页查询 */
+    async selectPage(page = {}, wrapper, options) {
+        const current = (0, security_1.assertSafeUint)(Math.max(1, page.current ?? 1), "current");
+        const size = (0, security_1.assertSafeUint)(Math.max(1, page.size ?? 10), "size");
+        const offset = (0, security_1.assertSafeUint)((current - 1) * size, "offset");
+        await this.assertLogicDeleteColumn();
+        const frag = this.withLogic(wrapper).build();
+        const countSql = this.countSqlFromFrag(frag);
+        let listSql = `SELECT ${frag.selectSql} FROM ${this.tableSql()} ${this.fragTail(frag)}`.trim();
+        const hasOrder = /\bORDER\s+BY\b/i.test(listSql);
+        listSql = this.dialect.appendLimitOffset(listSql, size, offset, hasOrder);
+        const [countRows, listRows] = await Promise.all([
+            this.query(countSql, frag.params),
+            this.query(listSql, frag.params),
+        ]);
+        const records = (0, resultMap_1.mapResultRows)(listRows);
+        return {
+            records: await (0, hydrate_1.hydrateFieldSelects)(this.opts.entity, records, this.hydrateOpts(options)),
+            total: Number(countRows[0]?.cnt ?? countRows[0]?.CNT ?? 0),
+            current,
+            size,
+        };
+    }
+    /** 解析有效主键策略 */
+    resolveIdType() {
+        const idMeta = this.opts.entity
+            ? (0, entityDecorators_1.getEntityIdField)(this.opts.entity)
+            : undefined;
+        const annotated = idMeta?.idType ?? IdType_1.IdType.NONE;
+        if (annotated !== IdType_1.IdType.NONE)
+            return annotated;
+        return (0, IdType_1.resolveIdType)(this.cfg().idType ?? IdType_1.IdType.AUTO);
+    }
+    /** 插入前按 IdType 填充 / 剥离主键 */
+    async applyIdOnInsert(row, entity) {
+        const idType = this.resolveIdType();
+        const col = this.opts.idField;
+        const prop = this.opts.entity != null
+            ? ((0, entityDecorators_1.getEntityIdField)(this.opts.entity)?.property ?? col)
+            : col;
+        const current = row[col] !== undefined
+            ? row[col]
+            : row[prop] !== undefined
+                ? row[prop]
+                : entity?.[prop] ?? entity?.[col];
+        if (idType === IdType_1.IdType.AUTO) {
+            // 数据库自增：不写入 id 列（已有值则保留，兼容显式指定）
+            if (current === undefined || current === null || current === "") {
+                delete row[col];
+                if (prop !== col)
+                    delete row[prop];
+            }
+            return;
+        }
+        if (idType === IdType_1.IdType.INPUT) {
+            return;
+        }
+        if (current !== undefined && current !== null && current !== "") {
+            row[col] = current;
+            return;
+        }
+        const gen = (0, identifier_1.getIdentifierGenerator)();
+        if (idType === IdType_1.IdType.ASSIGN_ID) {
+            row[col] = await gen.nextId(entity);
+            return;
+        }
+        if (idType === IdType_1.IdType.ASSIGN_UUID) {
+            row[col] = await gen.nextUUID(entity);
+        }
+    }
+    /** 把生成的主键回写到原始实体 */
+    writeBackId(entity, normalized, insertId) {
+        const col = this.opts.idField;
+        const prop = this.opts.entity != null
+            ? ((0, entityDecorators_1.getEntityIdField)(this.opts.entity)?.property ?? col)
+            : col;
+        const idType = this.resolveIdType();
+        let value = normalized[col];
+        if ((value === undefined || value === null) &&
+            idType === IdType_1.IdType.AUTO &&
+            insertId) {
+            value = insertId;
+        }
+        if (value === undefined || value === null)
+            return;
+        entity[prop] = value;
+        if (prop !== col) {
+            entity[col] = value;
+        }
+    }
+    /** 插入，返回自增 id（若有）；ASSIGN_* 时尽量回写实体并返回可解析的数字 */
+    async insert(entity) {
+        await this.assertLogicDeleteColumn();
+        const normalized = await this.prepareInsertRow(entity);
+        const insertId = await this.insertOne(normalized);
+        this.writeBackId(entity, normalized, insertId);
+        const back = entity[this.opts.idField];
+        if (insertId)
+            return insertId;
+        if (typeof back === "number")
+            return back;
+        if (typeof back === "string" && /^\d+$/.test(back))
+            return Number(back);
+        return 0;
+    }
+    /**
+     * 批量插入，返回影响行数。
+     * 多行一条 INSERT，按 `orm.batch.insertSize`（默认 200）分批。
+     */
+    async saveBatch(entities) {
+        const list = (entities ?? []).filter((item) => item != null && typeof item === "object");
+        if (list.length === 0)
+            return 0;
+        await this.assertLogicDeleteColumn();
+        return this.tx(async () => {
+            const rows = [];
+            for (const entity of list) {
+                const normalized = await this.prepareInsertRow(entity);
+                rows.push(normalized);
+                // ASSIGN_* 已写入 normalized，回写实体；AUTO 批量不回填单条 id
+                this.writeBackId(entity, normalized, 0);
+            }
+            const batchSize = Math.max(1, this.cfg().batchInsertSize ?? 200);
+            let affected = 0;
+            for (let i = 0; i < rows.length; i += batchSize) {
+                affected += await this.insertMany(rows.slice(i, i + batchSize));
+            }
+            return affected;
+        });
+    }
+    async prepareInsertRow(entity) {
+        const row = { ...entity };
+        await (0, fill_1.applyInsertFill)(row, this.cfg(), this.opts.fill);
+        await (0, entityDecorators_1.applyEntityFieldFills)(this.opts.entity, row, "insert");
+        await this.applyIdOnInsert(row, entity);
+        await this.stripMissingFillFields(row);
+        const normalized = this.normalizeEntityRow(row);
+        if (this.isLogicDelete() &&
+            normalized[this.opts.logicDeleteField] === undefined) {
+            normalized[this.opts.logicDeleteField] = this.opts.logicNotDeleteValue;
+        }
+        if (this.isOptimisticLock() &&
+            normalized[this.opts.versionField] === undefined) {
+            normalized[this.opts.versionField] = 1;
+        }
+        return normalized;
+    }
+    async insertOne(normalized) {
+        const keys = Object.keys(normalized).filter((k) => normalized[k] !== undefined);
+        if (keys.length === 0) {
+            throw new Error("insert 实体不能为空");
+        }
+        const safeKeys = keys.map(security_1.assertIdent);
+        const cols = safeKeys.map((k) => this.dialect.quoteIdent(k)).join(", ");
+        const placeholders = safeKeys.map(() => "?").join(", ");
+        const values = safeKeys.map((k) => normalized[k]);
+        const baseSql = `INSERT INTO ${this.tableSql()} (${cols}) VALUES (${placeholders})`;
+        const prepared = this.dialect.prepareInsert(baseSql, this.opts.idField);
+        const result = await this.query(prepared.sql, values);
+        return this.dialect.extractInsertId(result, this.opts.idField, prepared.returning);
+    }
+    /** 多行同一列集合；缺省列写 NULL */
+    async insertMany(rows) {
+        const keySet = new Set();
+        for (const row of rows) {
+            for (const key of Object.keys(row)) {
+                if (row[key] !== undefined)
+                    keySet.add(key);
+            }
+        }
+        const keys = [...keySet];
+        if (keys.length === 0) {
+            throw new Error("saveBatch 实体不能为空");
+        }
+        const safeKeys = keys.map(security_1.assertIdent);
+        const cols = safeKeys.map((k) => this.dialect.quoteIdent(k)).join(", ");
+        const rowPlaceholder = `(${safeKeys.map(() => "?").join(", ")})`;
+        const values = [];
+        for (const row of rows) {
+            for (const key of safeKeys) {
+                values.push(row[key] === undefined ? null : row[key]);
+            }
+        }
+        const sql = `INSERT INTO ${this.tableSql()} (${cols}) VALUES ${rows
+            .map(() => rowPlaceholder)
+            .join(", ")}`;
+        const result = await this.query(sql, values);
+        return this.dialect.extractAffectedRows(result);
+    }
+    /** 按主键更新（忽略 undefined 字段） */
+    async updateById(entity) {
+        const id = entity[this.opts.idField];
+        if (id === undefined || id === null) {
+            throw new Error(`updateById 缺少主键 ${this.opts.idField}`);
+        }
+        const row = { ...entity };
+        await (0, fill_1.applyUpdateFill)(row, this.cfg(), this.opts.fill);
+        await (0, entityDecorators_1.applyEntityFieldFills)(this.opts.entity, row, "update");
+        await this.stripMissingFillFields(row);
+        const normalized = this.normalizeEntityRow(row);
+        await this.assertLogicDeleteColumn();
+        const version = this.isOptimisticLock() &&
+            normalized[this.opts.versionField] !== undefined
+            ? normalized[this.opts.versionField]
+            : undefined;
+        const keys = Object.keys(normalized).filter((k) => k !== this.opts.idField &&
+            k !== this.opts.versionField &&
+            this.shouldWriteUpdateValue(normalized[k]));
+        const sets = keys.map((k) => `${this.colSql(k)} = ?`);
+        const values = keys.map((k) => normalized[k]);
+        if (version !== undefined) {
+            sets.push(`${this.colSql(this.opts.versionField)} = ${this.colSql(this.opts.versionField)} + 1`);
+        }
+        if (sets.length === 0)
+            return 0;
+        let where = `${this.idSql()} = ?`;
+        const whereParams = [id];
+        if (version !== undefined) {
+            where += ` AND ${this.colSql(this.opts.versionField)} = ?`;
+            whereParams.push(version);
+        }
+        if (this.isLogicDelete()) {
+            const nd = this.notDeletedClause();
+            where += ` AND ${nd.sql}`;
+            whereParams.push(...nd.params);
+        }
+        const sql = `UPDATE ${this.tableSql()} SET ${sets.join(", ")} WHERE ${where}`;
+        const result = await this.query(sql, [...values, ...whereParams]);
+        const affected = this.dialect.extractAffectedRows(result);
+        if (version !== undefined && affected === 0) {
+            throw new errors_1.OptimisticLockError();
+        }
+        return affected;
+    }
+    /**
+     * 有主键且库中存在则 updateById，否则 insert。
+     * 返回影响行数（insert / update 语义与各自方法一致）。
+     */
+    async saveOrUpdate(entity) {
+        const id = entity[this.opts.idField];
+        if (id === undefined || id === null || id === "") {
+            return this.insert(entity);
+        }
+        const existing = await this.selectById(id);
+        if (!existing) {
+            return this.insert(entity);
+        }
+        return this.updateById(entity);
+    }
+    /**
+     * 按主键批量更新（逐条 updateById，同一事务）。
+     * 分批大小取 `orm.batch.updateSize`（默认 200）。
+     */
+    async updateBatch(entities) {
+        const list = (entities ?? []).filter((item) => item != null && typeof item === "object");
+        if (list.length === 0)
+            return 0;
+        const batchSize = Math.max(1, this.cfg().batchUpdateSize ?? 200);
+        return this.tx(async () => {
+            let affected = 0;
+            for (let i = 0; i < list.length; i += batchSize) {
+                const chunk = list.slice(i, i + batchSize);
+                for (const entity of chunk) {
+                    affected += await this.updateById(entity);
+                }
+            }
+            return affected;
+        });
+    }
+    /** 条件更新 */
+    async update(entity, wrapper) {
+        await this.assertLogicDeleteColumn();
+        const frag = this.withLogic(wrapper).build();
+        if (!frag.whereSql) {
+            throw new Error("update 必须带 WHERE 条件，防止全表更新");
+        }
+        const row = { ...entity };
+        await (0, fill_1.applyUpdateFill)(row, this.cfg(), this.opts.fill);
+        await (0, entityDecorators_1.applyEntityFieldFills)(this.opts.entity, row, "update");
+        await this.stripMissingFillFields(row);
+        const normalized = this.normalizeEntityRow(row);
+        const version = this.isOptimisticLock() &&
+            normalized[this.opts.versionField] !== undefined
+            ? normalized[this.opts.versionField]
+            : undefined;
+        const keys = Object.keys(normalized).filter((k) => k !== this.opts.versionField &&
+            this.shouldWriteUpdateValue(normalized[k]));
+        const sets = keys.map((k) => `${this.colSql(k)} = ?`);
+        const values = keys.map((k) => normalized[k]);
+        if (version !== undefined) {
+            sets.push(`${this.colSql(this.opts.versionField)} = ${this.colSql(this.opts.versionField)} + 1`);
+        }
+        if (sets.length === 0)
+            return 0;
+        let whereSql = frag.whereSql;
+        const params = [...frag.params];
+        if (version !== undefined) {
+            whereSql += ` AND ${this.colSql(this.opts.versionField)} = ?`;
+            params.push(version);
+        }
+        const sql = `UPDATE ${this.tableSql()} SET ${sets.join(", ")} ${whereSql} ${frag.lastSql}`.trim();
+        const result = await this.query(sql, [...values, ...params]);
+        const affected = this.dialect.extractAffectedRows(result);
+        if (version !== undefined && affected === 0) {
+            throw new errors_1.OptimisticLockError();
+        }
+        return affected;
+    }
+    /** 按主键删除（开启逻辑删除时改为 UPDATE） */
+    async deleteById(id) {
+        return this.deleteByIds([id]);
+    }
+    /**
+     * 按主键批量删除，返回影响行数。
+     * 开启逻辑删除时一条 UPDATE ... IN (...)，否则物理 DELETE。
+     */
+    async deleteByIds(ids) {
+        return this.deleteByIdsInternal(ids, false);
+    }
+    /**
+     * 按主键物理删除（始终 DELETE，忽略逻辑删除开关）。
+     * 用于彻底清除或回收站清空。
+     */
+    async physicalDeleteById(id) {
+        return this.physicalDeleteByIds([id]);
+    }
+    /** 按主键批量物理删除 */
+    async physicalDeleteByIds(ids) {
+        return this.deleteByIdsInternal(ids, true);
+    }
+    /** 条件删除（开启逻辑删除时改为 UPDATE） */
+    async delete(wrapper) {
+        return this.deleteByWrapper(wrapper, false);
+    }
+    /**
+     * 条件物理删除（始终 DELETE）。
+     * 必须带 WHERE；不会自动附加「未删除」条件（可删已逻辑删除行）。
+     */
+    async physicalDelete(wrapper) {
+        return this.deleteByWrapper(wrapper, true);
+    }
+    async deleteByIdsInternal(ids, physical) {
+        const list = (ids ?? []).filter((id) => id !== undefined && id !== null);
+        if (list.length === 0)
+            return 0;
+        if (!physical) {
+            await this.assertLogicDeleteColumn();
+        }
+        const batchSize = Math.max(1, this.cfg().batchInSize ?? 500);
+        return this.tx(async () => {
+            let affected = 0;
+            for (let i = 0; i < list.length; i += batchSize) {
+                const chunk = list.slice(i, i + batchSize);
+                const placeholders = chunk.map(() => "?").join(", ");
+                if (physical || !this.isLogicDelete()) {
+                    const sql = `DELETE FROM ${this.tableSql()} WHERE ${this.idSql()} IN (${placeholders})`;
+                    const result = await this.query(sql, chunk);
+                    affected += this.dialect.extractAffectedRows(result);
+                    continue;
+                }
+                const nd = this.notDeletedClause();
+                affected += await this.logicDeleteBy(`${this.idSql()} IN (${placeholders}) AND ${nd.sql}`, [...chunk, ...nd.params]);
+            }
+            return affected;
+        });
+    }
+    async deleteByWrapper(wrapper, physical) {
+        if (!physical) {
+            await this.assertLogicDeleteColumn();
+        }
+        const frag = physical
+            ? (wrapper ?? new QueryWrapper_1.QueryWrapper(this.dialect)).build()
+            : this.withLogic(wrapper).build();
+        if (!frag.whereSql) {
+            throw new Error(`${physical ? "physicalDelete" : "delete"} 必须带 WHERE 条件，防止全表删除`);
+        }
+        if (physical || !this.isLogicDelete()) {
+            const sql = `DELETE FROM ${this.tableSql()} ${frag.whereSql} ${frag.lastSql}`.trim();
+            const result = await this.query(sql, frag.params);
+            return this.dialect.extractAffectedRows(result);
+        }
+        return this.logicDeleteBy(frag.whereSql.replace(/^WHERE\s+/i, ""), frag.params);
+    }
+    async logicDeleteBy(whereBody, whereParams) {
+        const patch = {
+            [this.opts.logicDeleteField]: this.opts.logicDeleteValue,
+        };
+        await (0, fill_1.applyUpdateFill)(patch, this.cfg(), this.opts.fill);
+        await (0, entityDecorators_1.applyEntityFieldFills)(this.opts.entity, patch, "update");
+        await this.stripMissingFillFields(patch);
+        const keys = Object.keys(patch).filter((k) => patch[k] !== undefined);
+        const sets = keys.map((k) => `${this.colSql(k)} = ?`).join(", ");
+        const values = keys.map((k) => patch[k]);
+        const sql = `UPDATE ${this.tableSql()} SET ${sets} WHERE ${whereBody}`;
+        const result = await this.query(sql, [...values, ...whereParams]);
+        return this.dialect.extractAffectedRows(result);
+    }
+}
+exports.BaseMapper = BaseMapper;
+//# sourceMappingURL=BaseMapper.js.map