node-mybatis-plus 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1006 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import "reflect-metadata";
+
+// src/decorator/index.ts
+import "reflect-metadata";
+var metadataCache = /* @__PURE__ */ new Map();
+function Table(tableName) {
+  return (target) => {
+    const existing = getOrCreateMeta(target);
+    existing.tableName = tableName;
+    metadataCache.set(target, existing);
+  };
+}
+function Id(options) {
+  return (target, propertyKey) => {
+    const meta = getOrCreateMeta(target.constructor);
+    const col = ensureColumn(meta, propertyKey);
+    col.isPrimary = true;
+    col.idType = options?.type ?? "auto";
+    meta.idColumn = col;
+  };
+}
+function Column(nameOrOptions) {
+  return (target, propertyKey) => {
+    const meta = getOrCreateMeta(target.constructor);
+    const col = ensureColumn(meta, propertyKey);
+    if (typeof nameOrOptions === "string") {
+      col.columnName = nameOrOptions;
+    } else if (nameOrOptions) {
+      if (nameOrOptions.name) col.columnName = nameOrOptions.name;
+      if (nameOrOptions.exist === false) col.exist = false;
+    }
+  };
+}
+function getOrCreateMeta(target) {
+  let meta = metadataCache.get(target);
+  if (!meta) {
+    meta = { tableName: "", columns: [], idColumn: null, target };
+    metadataCache.set(target, meta);
+  }
+  return meta;
+}
+function ensureColumn(meta, propertyName) {
+  let col = meta.columns.find((c) => c.propertyName === propertyName);
+  if (!col) {
+    col = {
+      propertyName,
+      columnName: camelToSnake(propertyName),
+      isPrimary: false,
+      exist: true
+    };
+    meta.columns.push(col);
+  }
+  return col;
+}
+function getEntityMeta(target) {
+  const meta = metadataCache.get(target);
+  if (!meta) throw new Error(`No entity metadata found for ${target.name}. Did you forget @Table?`);
+  return meta;
+}
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+
+// src/dialect/index.ts
+var MysqlDialect = class {
+  placeholder(_index) {
+    return "?";
+  }
+  quote(identifier) {
+    return `\`${identifier}\``;
+  }
+  paginate(sql, offset, limit) {
+    return `${sql} LIMIT ${limit} OFFSET ${offset}`;
+  }
+  insertReturningId() {
+    return null;
+  }
+};
+var PostgresDialect = class {
+  placeholder(index) {
+    return `$${index}`;
+  }
+  quote(identifier) {
+    return `"${identifier}"`;
+  }
+  paginate(sql, offset, limit) {
+    return `${sql} LIMIT ${limit} OFFSET ${offset}`;
+  }
+  insertReturningId(_table, _columns, idColumn) {
+    return `RETURNING "${idColumn}"`;
+  }
+};
+var SqliteDialect = class {
+  placeholder(_index) {
+    return "?";
+  }
+  quote(identifier) {
+    return `"${identifier}"`;
+  }
+  paginate(sql, offset, limit) {
+    return `${sql} LIMIT ${limit} OFFSET ${offset}`;
+  }
+  insertReturningId() {
+    return null;
+  }
+};
+function createDialect(type) {
+  switch (type) {
+    case "mysql":
+      return new MysqlDialect();
+    case "postgres":
+      return new PostgresDialect();
+    case "sqlite":
+      return new SqliteDialect();
+    default:
+      throw new Error(`Unsupported dialect: ${type}`);
+  }
+}
+
+// src/core/transaction.ts
+import { AsyncLocalStorage } from "async_hooks";
+var txStore = new AsyncLocalStorage();
+function getCurrentTxConnection() {
+  return txStore.getStore();
+}
+async function withTransaction(ds, fn) {
+  const existing = txStore.getStore();
+  if (existing && existing.datasource === ds) {
+    return fn();
+  }
+  const conn = await ds.getConnection();
+  await conn.query("BEGIN", []);
+  const ctx = { connection: conn, datasource: ds };
+  try {
+    const result = await txStore.run(ctx, fn);
+    await conn.query("COMMIT", []);
+    return result;
+  } catch (e) {
+    await conn.query("ROLLBACK", []);
+    throw e;
+  } finally {
+    conn.release();
+  }
+}
+var defaultDataSource = null;
+function setDefaultDataSource(ds) {
+  defaultDataSource = ds;
+}
+function getDefaultDataSource() {
+  if (!defaultDataSource) throw new Error("No default DataSource set. Call setDefaultDataSource() first.");
+  return defaultDataSource;
+}
+function Transactional(options) {
+  return (_target, _propertyKey, descriptor) => {
+    const original = descriptor.value;
+    descriptor.value = async function(...args) {
+      const ds = options?.datasource ?? defaultDataSource;
+      if (!ds) throw new Error("No DataSource available for @Transactional. Set default or pass in options.");
+      return withTransaction(ds, () => original.apply(this, args));
+    };
+    return descriptor;
+  };
+}
+
+// src/core/datasource.ts
+async function txAwareExecute(ds, sql, params) {
+  const txCtx = getCurrentTxConnection();
+  if (txCtx && txCtx.datasource === ds) {
+    return txCtx.connection.query(sql, params);
+  }
+  return null;
+}
+var MysqlConnection = class {
+  constructor(conn) {
+    this.conn = conn;
+  }
+  async query(sql, params) {
+    const cmd = sql.trimStart().toUpperCase();
+    if (cmd.startsWith("BEGIN") || cmd.startsWith("COMMIT") || cmd.startsWith("ROLLBACK") || cmd.startsWith("START")) {
+      const [rows2] = await this.conn.query(sql, params);
+      return rows2;
+    }
+    const [rows] = await this.conn.execute(sql, params);
+    return rows;
+  }
+  release() {
+    this.conn.release();
+  }
+};
+var MysqlDataSource = class {
+  constructor(config) {
+    this.config = config;
+    this.dialect = createDialect("mysql");
+    this.plugins = config.plugins ?? [];
+  }
+  dialect;
+  plugins;
+  pool;
+  async getPool() {
+    if (!this.pool) {
+      const mysql2 = await import("mysql2/promise");
+      this.pool = mysql2.createPool({
+        host: this.config.host ?? "localhost",
+        port: this.config.port ?? 3306,
+        database: this.config.database,
+        user: this.config.username,
+        password: this.config.password,
+        waitForConnections: true,
+        connectionLimit: this.config.pool?.max ?? 10
+      });
+    }
+    return this.pool;
+  }
+  async getConnection() {
+    const pool = await this.getPool();
+    const conn = await pool.getConnection();
+    return new MysqlConnection(conn);
+  }
+  async execute(sql, params) {
+    const txResult = await txAwareExecute(this, sql, params);
+    if (txResult !== null) return txResult;
+    const pool = await this.getPool();
+    const [rows] = await pool.execute(sql, params);
+    return rows;
+  }
+  async transaction(fn) {
+    const pool = await this.getPool();
+    const conn = await pool.getConnection();
+    await conn.beginTransaction();
+    const tx = {
+      connection: new MysqlConnection(conn),
+      async commit() {
+        await conn.commit();
+      },
+      async rollback() {
+        await conn.rollback();
+      }
+    };
+    try {
+      const result = await fn(tx);
+      await conn.commit();
+      return result;
+    } catch (e) {
+      await conn.rollback();
+      throw e;
+    } finally {
+      conn.release();
+    }
+  }
+  async close() {
+    if (this.pool) await this.pool.end();
+  }
+};
+var PgConnection = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async query(sql, params) {
+    const result = await this.client.query(sql, params);
+    return result.rows;
+  }
+  release() {
+    this.client.release();
+  }
+};
+var PostgresDataSource = class {
+  constructor(config) {
+    this.config = config;
+    this.dialect = createDialect("postgres");
+    this.plugins = config.plugins ?? [];
+  }
+  dialect;
+  plugins;
+  pool;
+  async getPool() {
+    if (!this.pool) {
+      const { Pool } = await import("pg");
+      this.pool = new Pool({
+        host: this.config.host ?? "localhost",
+        port: this.config.port ?? 5432,
+        database: this.config.database,
+        user: this.config.username,
+        password: this.config.password,
+        min: this.config.pool?.min ?? 2,
+        max: this.config.pool?.max ?? 10,
+        idleTimeoutMillis: this.config.pool?.idleTimeout ?? 3e4
+      });
+    }
+    return this.pool;
+  }
+  async getConnection() {
+    const pool = await this.getPool();
+    const client = await pool.connect();
+    return new PgConnection(client);
+  }
+  async execute(sql, params) {
+    const txResult = await txAwareExecute(this, sql, params);
+    if (txResult !== null) return txResult;
+    const pool = await this.getPool();
+    const result = await pool.query(sql, params);
+    return result.rows;
+  }
+  async transaction(fn) {
+    const pool = await this.getPool();
+    const client = await pool.connect();
+    await client.query("BEGIN");
+    const tx = {
+      connection: new PgConnection(client),
+      async commit() {
+        await client.query("COMMIT");
+      },
+      async rollback() {
+        await client.query("ROLLBACK");
+      }
+    };
+    try {
+      const result = await fn(tx);
+      await client.query("COMMIT");
+      return result;
+    } catch (e) {
+      await client.query("ROLLBACK");
+      throw e;
+    } finally {
+      client.release();
+    }
+  }
+  async close() {
+    if (this.pool) await this.pool.end();
+  }
+};
+var SqliteConnection = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async query(sql, params) {
+    const trimmed = sql.trimStart().toUpperCase();
+    if (trimmed.startsWith("SELECT") || trimmed.startsWith("WITH")) {
+      return this.db.prepare(sql).all(...params);
+    }
+    return this.db.prepare(sql).run(...params);
+  }
+  release() {
+  }
+};
+var SqliteDataSource = class {
+  constructor(config) {
+    this.config = config;
+    this.dialect = createDialect("sqlite");
+    this.plugins = config.plugins ?? [];
+  }
+  dialect;
+  plugins;
+  db;
+  getDb() {
+    if (!this.db) {
+      const Database = __require("better-sqlite3");
+      this.db = new Database(this.config.database);
+      this.db.pragma("journal_mode = WAL");
+    }
+    return this.db;
+  }
+  async getConnection() {
+    return new SqliteConnection(this.getDb());
+  }
+  async execute(sql, params) {
+    const txResult = await txAwareExecute(this, sql, params);
+    if (txResult !== null) return txResult;
+    const conn = await this.getConnection();
+    return conn.query(sql, params);
+  }
+  async transaction(fn) {
+    const db = this.getDb();
+    const conn = new SqliteConnection(db);
+    db.prepare("BEGIN").run();
+    const tx = {
+      connection: conn,
+      async commit() {
+        db.prepare("COMMIT").run();
+      },
+      async rollback() {
+        db.prepare("ROLLBACK").run();
+      }
+    };
+    try {
+      const result = await fn(tx);
+      db.prepare("COMMIT").run();
+      return result;
+    } catch (e) {
+      db.prepare("ROLLBACK").run();
+      throw e;
+    }
+  }
+  async close() {
+    if (this.db) this.db.close();
+  }
+};
+function createDataSource(config) {
+  switch (config.type) {
+    case "mysql":
+      return new MysqlDataSource(config);
+    case "postgres":
+      return new PostgresDataSource(config);
+    case "sqlite":
+      return new SqliteDataSource(config);
+    default:
+      throw new Error(`Unsupported database type: ${config.type}`);
+  }
+}
+
+// src/wrapper/abstract-wrapper.ts
+var AbstractWrapper = class {
+  constructor(entityMeta) {
+    this.entityMeta = entityMeta;
+  }
+  conditionGroup = { logic: "AND", items: [] };
+  _orderBy = [];
+  _groupBy = [];
+  _having = null;
+  eq(...args) {
+    return this.addCondition("=", args);
+  }
+  ne(...args) {
+    return this.addCondition("!=", args);
+  }
+  gt(...args) {
+    return this.addCondition(">", args);
+  }
+  ge(...args) {
+    return this.addCondition(">=", args);
+  }
+  lt(...args) {
+    return this.addCondition("<", args);
+  }
+  le(...args) {
+    return this.addCondition("<=", args);
+  }
+  like(...args) {
+    return this.addCondition("LIKE", args, (v) => `%${v}%`);
+  }
+  likeLeft(...args) {
+    return this.addCondition("LIKE", args, (v) => `%${v}`);
+  }
+  likeRight(...args) {
+    return this.addCondition("LIKE", args, (v) => `${v}%`);
+  }
+  between(...args) {
+    const { active, column, values } = this.parseArgs(args, 2);
+    if (active) {
+      this.conditionGroup.items.push({
+        column: this.resolveColumn(column),
+        op: "BETWEEN",
+        value: values[0],
+        value2: values[1]
+      });
+    }
+    return this;
+  }
+  in(...args) {
+    return this.addCondition("IN", args);
+  }
+  notIn(...args) {
+    return this.addCondition("NOT IN", args);
+  }
+  isNull(...args) {
+    const hasCondition = typeof args[0] === "boolean";
+    const active = hasCondition ? args[0] : true;
+    const column = hasCondition ? args[1] : args[0];
+    if (active) {
+      this.conditionGroup.items.push({ column: this.resolveColumn(column), op: "IS NULL" });
+    }
+    return this;
+  }
+  isNotNull(...args) {
+    const hasCondition = typeof args[0] === "boolean";
+    const active = hasCondition ? args[0] : true;
+    const column = hasCondition ? args[1] : args[0];
+    if (active) {
+      this.conditionGroup.items.push({ column: this.resolveColumn(column), op: "IS NOT NULL" });
+    }
+    return this;
+  }
+  or(fn) {
+    const sub = this.createNested("OR");
+    fn(sub);
+    const nested = sub.conditionGroup;
+    if (nested.items.length) this.conditionGroup.items.push(nested);
+    return this;
+  }
+  and(fn) {
+    const sub = this.createNested("AND");
+    fn(sub);
+    const nested = sub.conditionGroup;
+    if (nested.items.length) this.conditionGroup.items.push(nested);
+    return this;
+  }
+  // ---- 排序 & 分组 ----
+  orderByAsc(...columns) {
+    for (const c of columns) this._orderBy.push({ column: this.resolveColumn(c), direction: "ASC" });
+    return this;
+  }
+  orderByDesc(...columns) {
+    for (const c of columns) this._orderBy.push({ column: this.resolveColumn(c), direction: "DESC" });
+    return this;
+  }
+  groupBy(...columns) {
+    this._groupBy.push(...columns.map((c) => this.resolveColumn(c)));
+    return this;
+  }
+  // ---- 内部方法 ----
+  resolveColumn(propertyName) {
+    const col = this.entityMeta.columns.find((c) => c.propertyName === propertyName);
+    return col ? col.columnName : propertyName;
+  }
+  getConditionGroup() {
+    return this.conditionGroup;
+  }
+  getOrderBy() {
+    return this._orderBy;
+  }
+  getGroupBy() {
+    return this._groupBy;
+  }
+  getHaving() {
+    return this._having;
+  }
+  addCondition(op, args, transform) {
+    const { active, column, values } = this.parseArgs(args, 1);
+    if (active) {
+      const value = transform ? transform(values[0]) : values[0];
+      this.conditionGroup.items.push({ column: this.resolveColumn(column), op, value });
+    }
+    return this;
+  }
+  parseArgs(args, valueCount) {
+    const hasCondition = typeof args[0] === "boolean";
+    const offset = hasCondition ? 1 : 0;
+    return {
+      active: hasCondition ? args[0] : true,
+      column: args[offset],
+      values: args.slice(offset + 1, offset + 1 + valueCount)
+    };
+  }
+  createNested(logic) {
+    const Ctor = this.constructor;
+    const nested = new Ctor(this.entityMeta);
+    nested.conditionGroup = { logic, items: [] };
+    return nested;
+  }
+};
+
+// src/builder/sql-builder.ts
+var SqlBuilder = class {
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  params = [];
+  paramIndex = 0;
+  build(node) {
+    this.params = [];
+    this.paramIndex = 0;
+    let sql;
+    switch (node.type) {
+      case "select":
+        sql = this.buildSelect(node);
+        break;
+      case "insert":
+        sql = this.buildInsert(node);
+        break;
+      case "update":
+        sql = this.buildUpdate(node);
+        break;
+      case "delete":
+        sql = this.buildDelete(node);
+        break;
+    }
+    return { sql, params: this.params };
+  }
+  buildSelect(node) {
+    const cols = node.columns.length ? node.columns.map((c) => this.q(c)).join(", ") : "*";
+    let sql = `SELECT ${cols} FROM ${this.q(node.table)}`;
+    if (node.where) {
+      const w = this.buildConditionGroup(node.where);
+      if (w) sql += ` WHERE ${w}`;
+    }
+    if (node.groupBy.length) {
+      sql += ` GROUP BY ${node.groupBy.map((c) => this.q(c)).join(", ")}`;
+    }
+    if (node.having) {
+      const h = this.buildConditionGroup(node.having);
+      if (h) sql += ` HAVING ${h}`;
+    }
+    if (node.orderBy.length) {
+      sql += ` ORDER BY ${node.orderBy.map((o) => `${this.q(o.column)} ${o.direction}`).join(", ")}`;
+    }
+    if (node.limit) {
+      sql = this.dialect.paginate(sql, node.limit.offset, node.limit.count);
+    }
+    return sql;
+  }
+  buildInsert(node) {
+    const cols = node.columns.map((c) => this.q(c)).join(", ");
+    const rows = node.values.map((row) => {
+      const placeholders = row.map((v) => this.addParam(v));
+      return `(${placeholders.join(", ")})`;
+    }).join(", ");
+    return `INSERT INTO ${this.q(node.table)} (${cols}) VALUES ${rows}`;
+  }
+  buildUpdate(node) {
+    const sets = node.sets.map((s) => `${this.q(s.column)} = ${this.addParam(s.value)}`).join(", ");
+    let sql = `UPDATE ${this.q(node.table)} SET ${sets}`;
+    if (node.where) {
+      const w = this.buildConditionGroup(node.where);
+      if (w) sql += ` WHERE ${w}`;
+    }
+    return sql;
+  }
+  buildDelete(node) {
+    let sql = `DELETE FROM ${this.q(node.table)}`;
+    if (node.where) {
+      const w = this.buildConditionGroup(node.where);
+      if (w) sql += ` WHERE ${w}`;
+    }
+    return sql;
+  }
+  buildConditionGroup(group) {
+    const parts = [];
+    for (const item of group.items) {
+      if ("logic" in item) {
+        const sub = this.buildConditionGroup(item);
+        if (sub) parts.push(`(${sub})`);
+      } else {
+        parts.push(this.buildCondition(item));
+      }
+    }
+    return parts.join(` ${group.logic} `);
+  }
+  buildCondition(cond) {
+    const col = this.q(cond.column);
+    switch (cond.op) {
+      case "IS NULL":
+        return `${col} IS NULL`;
+      case "IS NOT NULL":
+        return `${col} IS NOT NULL`;
+      case "BETWEEN":
+        return `${col} BETWEEN ${this.addParam(cond.value)} AND ${this.addParam(cond.value2)}`;
+      case "IN":
+      case "NOT IN": {
+        const list = cond.value.map((v) => this.addParam(v)).join(", ");
+        return `${col} ${cond.op} (${list})`;
+      }
+      default:
+        return `${col} ${cond.op} ${this.addParam(cond.value)}`;
+    }
+  }
+  addParam(value) {
+    this.params.push(value);
+    return this.dialect.placeholder(++this.paramIndex);
+  }
+  q(identifier) {
+    return this.dialect.quote(identifier);
+  }
+};
+
+// src/plugin/runner.ts
+async function runPlugins(ds, node, sql, params, entityMeta) {
+  const plugins = [...ds.plugins].sort((a, b) => a.order - b.order);
+  const ctx = { node, sql, params, entityMeta };
+  for (const p of plugins) {
+    if (p.beforeExecute) {
+      await p.beforeExecute(ctx);
+    }
+  }
+  let result = await ds.execute(ctx.sql, ctx.params);
+  for (const p of plugins) {
+    if (p.afterExecute) {
+      const r = await p.afterExecute(ctx, result);
+      if (r !== void 0) result = r;
+    }
+  }
+  return result;
+}
+
+// src/wrapper/query-wrapper.ts
+var LambdaQueryWrapper = class extends AbstractWrapper {
+  _columns = [];
+  _limit = null;
+  _datasource = null;
+  constructor(entityMeta) {
+    super(entityMeta);
+  }
+  /** 绑定数据源（由 BaseMapper 调用） */
+  bindDataSource(ds) {
+    this._datasource = ds;
+    return this;
+  }
+  select(...columns) {
+    this._columns = columns.map((c) => this.resolveColumn(c));
+    return this;
+  }
+  page(page, size) {
+    this._limit = { offset: (page - 1) * size, count: size };
+    return this;
+  }
+  /** 构建 SelectNode AST */
+  buildSelectNode() {
+    return {
+      type: "select",
+      table: this.entityMeta.tableName,
+      columns: this._columns,
+      where: this.conditionGroup.items.length ? this.conditionGroup : null,
+      orderBy: this._orderBy,
+      groupBy: this._groupBy,
+      having: this._having,
+      limit: this._limit
+    };
+  }
+  /** 终结操作：执行查询返回列表 */
+  async list() {
+    const ds = this.requireDs();
+    const node = this.buildSelectNode();
+    const builder = new SqlBuilder(ds.dialect);
+    const { sql, params } = builder.build(node);
+    if (ds.plugins.length) {
+      return runPlugins(ds, node, sql, params, this.entityMeta);
+    }
+    return ds.execute(sql, params);
+  }
+  /** 终结操作：查询单条 */
+  async one() {
+    this._limit = { offset: 0, count: 1 };
+    const list = await this.list();
+    return list[0] ?? null;
+  }
+  /** 终结操作：查询数量 */
+  async count() {
+    const ds = this.requireDs();
+    const node = {
+      ...this.buildSelectNode(),
+      columns: [],
+      orderBy: [],
+      limit: null
+    };
+    const builder = new SqlBuilder(ds.dialect);
+    const { sql, params } = builder.build(node);
+    const countSql = sql.replace(/^SELECT \* FROM/, "SELECT COUNT(*) AS total FROM");
+    let rows;
+    if (ds.plugins.length) {
+      rows = await runPlugins(ds, node, countSql, params, this.entityMeta);
+    } else {
+      rows = await ds.execute(countSql, params);
+    }
+    return Number(rows[0]?.total ?? rows[0]?.count ?? 0);
+  }
+  /** 终结操作：分页查询 */
+  async pageResult(page, size) {
+    this._limit = { offset: (page - 1) * size, count: size };
+    const [records, total] = await Promise.all([
+      this.list(),
+      this.count()
+    ]);
+    return {
+      records,
+      total,
+      page,
+      size,
+      pages: Math.ceil(total / size)
+    };
+  }
+  requireDs() {
+    if (!this._datasource) throw new Error("DataSource not bound. Use BaseMapper to create wrapper.");
+    return this._datasource;
+  }
+};
+
+// src/wrapper/update-wrapper.ts
+var LambdaUpdateWrapper = class extends AbstractWrapper {
+  _sets = [];
+  _datasource = null;
+  constructor(entityMeta) {
+    super(entityMeta);
+  }
+  bindDataSource(ds) {
+    this._datasource = ds;
+    return this;
+  }
+  set(...args) {
+    const hasCondition = typeof args[0] === "boolean";
+    const active = hasCondition ? args[0] : true;
+    const column = hasCondition ? args[1] : args[0];
+    const value = hasCondition ? args[2] : args[1];
+    if (active) {
+      this._sets.push({ column: this.resolveColumn(column), value });
+    }
+    return this;
+  }
+  buildUpdateNode() {
+    return {
+      type: "update",
+      table: this.entityMeta.tableName,
+      sets: this._sets,
+      where: this.conditionGroup.items.length ? this.conditionGroup : null
+    };
+  }
+  async execute() {
+    if (!this._datasource) throw new Error("DataSource not bound.");
+    if (!this._sets.length) throw new Error("No SET clause specified.");
+    const node = this.buildUpdateNode();
+    const builder = new SqlBuilder(this._datasource.dialect);
+    const { sql, params } = builder.build(node);
+    let result;
+    if (this._datasource.plugins.length) {
+      result = await runPlugins(this._datasource, node, sql, params, this.entityMeta);
+    } else {
+      result = await this._datasource.execute(sql, params);
+    }
+    return result?.affectedRows ?? result?.rowCount ?? result?.changes ?? 0;
+  }
+};
+
+// src/mapper/base-mapper.ts
+var BaseMapper = class {
+  entityMeta;
+  ds;
+  constructor(entityClass, datasource) {
+    this.entityMeta = getEntityMeta(entityClass);
+    this.ds = datasource;
+  }
+  // ---- 链式入口 ----
+  lambdaQuery() {
+    return new LambdaQueryWrapper(this.entityMeta).bindDataSource(this.ds);
+  }
+  lambdaUpdate() {
+    return new LambdaUpdateWrapper(this.entityMeta).bindDataSource(this.ds);
+  }
+  // ---- 新增 ----
+  async insert(entity) {
+    const { columns, values } = this.extractColumns(entity);
+    const node = { type: "insert", table: this.entityMeta.tableName, columns, values: [values] };
+    const { sql, params } = new SqlBuilder(this.ds.dialect).build(node);
+    const result = await this.executeWithPlugins(node, sql, params);
+    return result?.insertId ?? result?.[0]?.id ?? result?.lastInsertRowid ?? 0;
+  }
+  async insertBatch(entities) {
+    if (!entities.length) return 0;
+    const cols = this.getInsertableColumns();
+    const columns = cols.map((c) => c.columnName);
+    const values = entities.map((e) => cols.map((c) => e[c.propertyName]));
+    const node = { type: "insert", table: this.entityMeta.tableName, columns, values };
+    const { sql, params } = new SqlBuilder(this.ds.dialect).build(node);
+    const result = await this.executeWithPlugins(node, sql, params);
+    return result?.affectedRows ?? result?.rowCount ?? result?.changes ?? entities.length;
+  }
+  // ---- 删除 ----
+  async deleteById(id) {
+    const idCol = this.requireIdColumn();
+    const node = {
+      type: "delete",
+      table: this.entityMeta.tableName,
+      where: { logic: "AND", items: [{ column: idCol.columnName, op: "=", value: id }] }
+    };
+    const { sql, params } = new SqlBuilder(this.ds.dialect).build(node);
+    const result = await this.executeWithPlugins(node, sql, params);
+    return result?.affectedRows ?? result?.rowCount ?? result?.changes ?? 0;
+  }
+  async deleteBatchIds(ids) {
+    if (!ids.length) return 0;
+    const idCol = this.requireIdColumn();
+    const node = {
+      type: "delete",
+      table: this.entityMeta.tableName,
+      where: { logic: "AND", items: [{ column: idCol.columnName, op: "IN", value: ids }] }
+    };
+    const { sql, params } = new SqlBuilder(this.ds.dialect).build(node);
+    const result = await this.executeWithPlugins(node, sql, params);
+    return result?.affectedRows ?? result?.rowCount ?? result?.changes ?? 0;
+  }
+  async delete(wrapper) {
+    const group = wrapper.getConditionGroup();
+    const node = {
+      type: "delete",
+      table: this.entityMeta.tableName,
+      where: group.items.length ? group : null
+    };
+    const { sql, params } = new SqlBuilder(this.ds.dialect).build(node);
+    const result = await this.executeWithPlugins(node, sql, params);
+    return result?.affectedRows ?? result?.rowCount ?? result?.changes ?? 0;
+  }
+  // ---- 修改 ----
+  async updateById(entity) {
+    const idCol = this.requireIdColumn();
+    const idValue = entity[idCol.propertyName];
+    if (idValue == null) throw new Error("Entity must have id value for updateById");
+    const sets = this.entityMeta.columns.filter((c) => c.exist && !c.isPrimary && entity[c.propertyName] !== void 0).map((c) => ({ column: c.columnName, value: entity[c.propertyName] }));
+    if (!sets.length) throw new Error("No fields to update");
+    const node = {
+      type: "update",
+      table: this.entityMeta.tableName,
+      sets,
+      where: { logic: "AND", items: [{ column: idCol.columnName, op: "=", value: idValue }] }
+    };
+    const { sql, params } = new SqlBuilder(this.ds.dialect).build(node);
+    const result = await this.executeWithPlugins(node, sql, params);
+    return result?.affectedRows ?? result?.rowCount ?? result?.changes ?? 0;
+  }
+  async update(entity, wrapper) {
+    const sets = this.entityMeta.columns.filter((c) => c.exist && !c.isPrimary && entity[c.propertyName] !== void 0).map((c) => ({ column: c.columnName, value: entity[c.propertyName] }));
+    if (!sets.length) throw new Error("No fields to update");
+    const group = wrapper.getConditionGroup();
+    const node = {
+      type: "update",
+      table: this.entityMeta.tableName,
+      sets,
+      where: group.items.length ? group : null
+    };
+    const { sql, params } = new SqlBuilder(this.ds.dialect).build(node);
+    const result = await this.executeWithPlugins(node, sql, params);
+    return result?.affectedRows ?? result?.rowCount ?? result?.changes ?? 0;
+  }
+  // ---- 查询 ----
+  async selectById(id) {
+    const idCol = this.requireIdColumn();
+    return this.lambdaQuery().eq(idCol.propertyName, id).one();
+  }
+  async selectBatchIds(ids) {
+    if (!ids.length) return [];
+    const idCol = this.requireIdColumn();
+    return this.lambdaQuery().in(idCol.propertyName, ids).list();
+  }
+  async selectOne(wrapper) {
+    return wrapper.one();
+  }
+  async selectList(wrapper) {
+    return (wrapper ?? this.lambdaQuery()).list();
+  }
+  async selectCount(wrapper) {
+    return (wrapper ?? this.lambdaQuery()).count();
+  }
+  async selectPage(page, size, wrapper) {
+    return (wrapper ?? this.lambdaQuery()).pageResult(page, size);
+  }
+  // ---- 自定义 SQL ----
+  async rawQuery(sql, params = {}) {
+    const { parsedSql, parsedParams } = this.parseNamedParams(sql, params);
+    return this.ds.execute(parsedSql, parsedParams);
+  }
+  // ---- 内部方法 ----
+  extractColumns(entity) {
+    const cols = this.getInsertableColumns().filter((c) => entity[c.propertyName] !== void 0);
+    return {
+      columns: cols.map((c) => c.columnName),
+      values: cols.map((c) => entity[c.propertyName])
+    };
+  }
+  getInsertableColumns() {
+    return this.entityMeta.columns.filter((c) => c.exist && !(c.isPrimary && c.idType === "auto"));
+  }
+  requireIdColumn() {
+    if (!this.entityMeta.idColumn) throw new Error(`No @Id defined on ${this.entityMeta.target.name}`);
+    return this.entityMeta.idColumn;
+  }
+  parseNamedParams(sql, params) {
+    const parsedParams = [];
+    let index = 0;
+    const parsedSql = sql.replace(/#\{(\w+)\}/g, (_, key) => {
+      parsedParams.push(params[key]);
+      return this.ds.dialect.placeholder(++index);
+    });
+    return { parsedSql, parsedParams };
+  }
+  /** 通过插件链路执行 SQL */
+  executeWithPlugins(node, sql, params) {
+    if (this.ds.plugins.length) {
+      return runPlugins(this.ds, node, sql, params, this.entityMeta);
+    }
+    return this.ds.execute(sql, params);
+  }
+};
+export {
+  AbstractWrapper,
+  BaseMapper,
+  Column,
+  Id,
+  LambdaQueryWrapper,
+  LambdaUpdateWrapper,
+  MysqlDialect,
+  PostgresDialect,
+  SqlBuilder,
+  SqliteDialect,
+  Table,
+  Transactional,
+  createDataSource,
+  createDialect,
+  getDefaultDataSource,
+  runPlugins,
+  setDefaultDataSource,
+  withTransaction
+};
+//# sourceMappingURL=index.mjs.map