neopg 2.0.1 → 2.0.2

package/lib/ModelChain.js

@@ -2,9 +2,8 @@
 
 const makeId = require('./makeId.js')
 const makeTimestamp = require('./makeTimestamp.js')
-const TransactionScope = require('./TransactionScope.js')
 
-// [优化 1] 提取常量定义到类外部，提升性能
+// 提取常量定义
 const INT_TYPES = new Set([
     'int', 'integer', 'smallint', 'bigint', 
     'serial', 'bigserial', 'smallserial',
@@ -16,16 +15,7 @@ const FLOAT_TYPES = new Set([
     'money', 'double precision', 'float4', 'float8'
 ])
 
-/**
- * ModelChain - 链式查询构建器
- * 负责运行时的查询构建、SQL 拼装和结果处理。
- */
 class ModelChain {
-  /**
-   * @param {Object} ctx - 上下文 (NeoPG 实例 或 TransactionScope 实例)
-   * @param {ModelDef} def - 模型元数据
-   * @param {string} schema - 数据库 schema
-   */
   constructor(ctx, def, schema = 'public') {
     this.ctx = ctx
     this.def = def
@@ -34,102 +24,103 @@ class ModelChain {
     this.tableName = def.tableName
     this.schema = schema
 
-    // --- 查询状态 (AST Lite) ---
+    // --- 查询状态 ---
     this._conditions = []
     this._order = []
     this._limit = null
     this._offset = null
     this._columns = null
-    this._group = null
-    this._lock = null
     this._returning = null
     this._joins = []
     this._group = []
+    this._lock = null
 
-    // 内部状态标记
     this._isRaw = !!def.isRaw
+    this._executed = false
   }
 
-  // --- 静态构造器 ---
   static from(schemaObject) {
     return class AnonymousModel extends ModelChain {
       static schema = schemaObject
     }
   }
 
-  // --- 核心：链式调用 API ---
+  // --- 内部状态管理 ---
 
-  /**
-   * 添加 WHERE 条件
-   * 1. .where(sql`age > ${age}`) -> 原生片段 (Query)
-   * 2. .where({ a: 1 }) -> a=1
-   * 3. .where('age', '>', 18) -> age > 18 (兼容)
-   */
-  where(arg1, arg2, arg3) {
-      if (!arg1) return this
-      // 1. Fragment 检测
-      if (arg1.constructor && arg1.constructor.name === 'Query') {
-        this._conditions.push(arg1)
-        return this
-      }
-      
-      // 2. Object 写法
-      if (typeof arg1 === 'object' && !Array.isArray(arg1)) {
-        for (const k of Object.keys(arg1)) {
-          const v = arg1[k]
-
-          if (v === undefined) continue
+  _ensureActive() {
+    if (this._executed) {
+      throw new Error(
+        `[NeoPG] ModelChain for '${this.tableName}' has already been executed. ` +
+        `Do NOT reuse the chain variable. Use .clone() if you need to fork queries.`
+      )
+    }
+  }
 
-          if (v === null) this._conditions.push(this.sql`${this.sql(k)} IS NULL`)
-          else if (Array.isArray(v)) this._conditions.push(this.sql`${this.sql(k)} IN ${this.sql(v)}`)
-          else this._conditions.push(this.sql`${this.sql(k)} = ${v}`)
-        }
-  
-        return this
-      }
+  _destroy() {
+    this._executed = true
+    this.def = null
+    this.ctx = null
+    // this.sql = null // 可选：保留引用以便 debug，或者释放
+  }
 
-      // 3. String 写法
-      if (typeof arg1 === 'string') {
-          // .where('age', '>', 18)
-          if (arg3 !== undefined) {
-             this._conditions.push(this.sql`${this.sql(arg1)} ${this.sql.unsafe(arg2)} ${arg3}`)
-             return this
-          }
-          // .where('age', 18) -> age = 18
-          if (arg2 !== undefined) {
-             this._conditions.push(this.sql`${this.sql(arg1)} = ${arg2}`)
-             return this
-          }
-          // .where('id = ?', 123)
-          if (arg1.includes('?') && arg2 !== undefined) {
-             const p = arg1.split('?');
-             if(p.length===2) {
-               this._conditions.push(this.sql`${this.sql.unsafe(p[0])}${arg2}${this.sql.unsafe(p[1])}`)
-               return this
-             }
-          }
-          // .where('1=1') -> Raw SQL
-          // 注意：这里必须用 unsafe，否则 '1=1' 会被当成字符串值处理
-          this._conditions.push(this.sql.unsafe(arg1))
-      }
+  clone() {
+    this._ensureActive()
+    const copy = new ModelChain(this.ctx, this.def, this.schema)
+    
+    // 拷贝状态
+    copy._conditions = [...this._conditions]
+    copy._joins = [...this._joins]
+    copy._group = [...this._group]
+    copy._order = [...this._order]
+    
+    copy._limit = this._limit
+    copy._offset = this._offset
+    copy._lock = this._lock
+    if (this._columns) copy._columns = [...this._columns]
+    if (this._returning) copy._returning = [...this._returning]
 
-      return this
+    return copy
   }
 
-  whereIf(condition, arg1, arg2, arg3) {
-    if (condition) return this.where(arg1, arg2, arg3)
-    return this
-  }
+  // --- 构建方法 (无检测，高性能) ---
 
   select(columns) {
     if (!columns) return this
-
     if (typeof columns === 'string') {
         this._columns = columns.split(',').map(s => s.trim())
     } else if (Array.isArray(columns)) {
         this._columns = columns
     }
+    return this
+  }
 
+  limit(count, offset = 0) {
+    this._limit = count
+    this._offset = offset
+    return this
+  }
+
+  page(pageIndex, pageSize) {
+    return this.limit(pageSize, (pageIndex - 1) * pageSize)
+  }
+
+  forUpdate() {
+    this._lock = this.sql`FOR UPDATE`
+    return this
+  }
+
+  forShare() {
+    this._lock = this.sql`FOR SHARE`
+    return this
+  }
+
+  returning(cols) {
+    if (!cols) return this
+    if (typeof cols === 'string') {
+      this._returning = cols.split(',').map(s => s.trim()).filter(s => s)
+    } else if (Array.isArray(cols)) {
+      this._returning = cols
+    }
     return this
   }
 
@@ -145,7 +136,6 @@ class ModelChain {
         for(const k in a) {
           this._order.push(this.sql`${this.sql(k)} ${this.sql.unsafe(a[k].toUpperCase())}`)
         }
-        
         return this
       }
 
@@ -154,104 +144,131 @@ class ModelChain {
         if(a.includes(' ')) this._order.push(this.sql.unsafe(a));
         else this._order.push(this.sql`${this.sql(a)} ${this.sql.unsafe(d)}`);
       }
-
       return this
   }
 
-  limit(count, offset = 0) {
-    this._limit = count
-    this._offset = offset
+  group(arg) {
+    if (!arg) return this
+    if (arg.constructor && arg.constructor.name === 'Query') {
+      this._group.push(arg)
+      return this
+    }
+    if (Array.isArray(arg)) {
+      arg.forEach(f => this.group(f))
+      return this
+    }
+    if (typeof arg === 'string') {
+      if (arg.includes(',')) {
+        arg.split(',').map(s => s.trim()).filter(s=>s).forEach(s => {
+          this._group.push(this.sql(s))
+        })
+      } else {
+        this._group.push(this.sql(arg))
+      }
+    }
     return this
   }
 
-  page(pageIndex, pageSize) {
-    return this.limit(pageSize, (pageIndex - 1) * pageSize)
-  }
+  // --- 特殊构建：Where (需要检测) ---
 
-  forUpdate() {
-    this._lock = this.sql`FOR UPDATE`
-    return this
-  }
+  where(arg1, arg2, arg3) {
+      // ⚠️ 只有 where 需要提前检测，防止条件污染
+      this._ensureActive()
 
-  forShare() {
-    this._lock = this.sql`FOR SHARE`
-    return this
-  }
+      if (!arg1) return this
 
-  returning(cols) {
-    if (!cols) return this
+      if (arg1.constructor && arg1.constructor.name === 'Query') {
+        this._conditions.push(arg1)
+        return this
+      }
+      
+      if (typeof arg1 === 'object' && !Array.isArray(arg1)) {
+        for (const k of Object.keys(arg1)) {
+          const v = arg1[k]
+          if (v === undefined) continue
+          if (v === null) this._conditions.push(this.sql`${this.sql(k)} IS NULL`)
+          else if (Array.isArray(v)) this._conditions.push(this.sql`${this.sql(k)} IN ${this.sql(v)}`)
+          else this._conditions.push(this.sql`${this.sql(k)} = ${v}`)
+        }
+        return this
+      }
 
-    if (typeof cols === 'string') {
-      // 支持 'id, name' 写法
-      this._returning = cols.split(',').map(s => s.trim()).filter(s => s)
-    } else if (Array.isArray(cols)) {
-      this._returning = cols
-    }
+      if (typeof arg1 === 'string') {
+          if (arg3 !== undefined) {
+             this._conditions.push(this.sql`${this.sql(arg1)} ${this.sql.unsafe(arg2)} ${arg3}`)
+             return this
+          }
+          if (arg2 !== undefined) {
+             this._conditions.push(this.sql`${this.sql(arg1)} = ${arg2}`)
+             return this
+          }
+          if (arg1.includes('?') && arg2 !== undefined) {
+             const p = arg1.split('?');
+             if(p.length===2) {
+               this._conditions.push(this.sql`${this.sql.unsafe(p[0])}${arg2}${this.sql.unsafe(p[1])}`)
+               return this
+             }
+          }
+          this._conditions.push(this.sql.unsafe(arg1))
+      }
+      return this
+  }
 
+  whereIf(condition, arg1, arg2, arg3) {
+    if (condition) return this.where(arg1, arg2, arg3)
     return this
   }
 
-  // --- 构建 RETURNING 片段 ---
-  _buildReturning() {
-    // 如果没有设置 returning，默认不返回数据 (节省性能)
-    // 注意：这意味着默认 insert/update 返回的是 Result 对象(包含 count)，而不是行数据
-    if (!this._returning || this._returning.length === 0) {
-        return this.sql``
-    }
-
-    // 特殊处理 '*': 用户显式要求 returning('*')
-    // 如果直接用 this.sql(['*']) 会被转义为 "*"，导致错误
-    if (this._returning.length === 1 && this._returning[0] === '*') {
-        return this.sql`RETURNING *`
-    }
-
-    // 普通字段：利用 postgres.js 自动转义标识符
-    return this.sql`RETURNING ${this.sql(this._returning)}`
-  }
+  // --- SQL 构建辅助 (内部方法) ---
 
-   // --- 辅助：构建 Where 片段 (修复 Bug 的核心) ---
   _buildWhere() {
     const len = this._conditions.length
     if (len === 0) return this.sql``
-    
-    // 只有一个条件，直接返回，零开销
-    if (len === 1) {
-      return this.sql`WHERE ${this._conditions[0]}`
-    }
+    if (len === 1) return this.sql`WHERE ${this._conditions[0]}`
 
-    // 预分配数组：N个条件需要 N-1 个 'AND'，总长 2N-1
-    // 使用 new Array 预分配内存，比 push 更快
     const parts = new Array(len * 2 - 1)
     const AND = this.sql.unsafe(' AND ')
-
     for (let i = 0; i < len; i++) {
-      // 偶数位放条件
       parts[i * 2] = this._conditions[i]
-      // 奇数位放 AND (除了最后一位)
-      if (i < len - 1) {
-        parts[i * 2 + 1] = AND
-      }
+      if (i < len - 1) parts[i * 2 + 1] = AND
     }
-
-    // postgres.js 会自动展开这个扁平数组，性能极高
     return this.sql`WHERE ${parts}`
   }
 
-  // --- 辅助：构建 Order 片段 (修复 Bug) ---
+  _buildReturning() {
+    if (!this._returning || this._returning.length === 0) return this.sql``
+    if (this._returning.length === 1 && this._returning[0] === '*') return this.sql`RETURNING *`
+    return this.sql`RETURNING ${this.sql(this._returning)}`
+  }
+
   _buildOrder() {
     if (this._order.length === 0) return this.sql``
-    // 数组直接传入模板，postgres.js 默认用逗号连接，这正是 ORDER BY 需要的
-    // 不能用 this.sql(this._order)，那样会试图转义为标识符
     return this.sql`ORDER BY ${this._order}`
   }
 
-  // --- 核心：执行方法 ---
+  _buildJoins() {
+    const len = this._joins.length
+    if (len === 0) return this.sql``
+    if (len === 1) return this._joins[0]
 
-  async find() {
+    const parts = new Array(len * 2 - 1)
+    const SPACE = this.sql.unsafe(' ')
+    for (let i = 0; i < len; i++) {
+      parts[i * 2] = this._joins[i]
+      if (i < len - 1) parts[i * 2 + 1] = SPACE
+    }
+    return this.sql`${parts}`
+  }
+
+  _buildGroup() {
+    if (this._group.length === 0) return this.sql``
+    return this.sql`GROUP BY ${this._group}`
+  }
+
+  _buildSelectQuery() {
     const t = this.sql(this.tableName)
     const c = this._columns ? this.sql(this._columns) : this.sql`*`
     
-    // 修复：使用新方法构建
     const w = this._buildWhere()
     const o = this._buildOrder()
     const j = this._buildJoins()
@@ -262,343 +279,244 @@ class ModelChain {
     const lck = this._lock || this.sql``
     const ft = this.sql`${this.sql(this.schema)}.${t}`
     
-    return await this.sql`SELECT ${c} FROM ${ft} ${j} ${w} ${g} ${o} ${l} ${off} ${lck}`
+    return this.sql`SELECT ${c} FROM ${ft} ${j} ${w} ${g} ${o} ${l} ${off} ${lck}`
+  }
+
+  // --- 执行动作 (Executors) ---
+  // 必须检测 _ensureActive 并在 finally 中销毁
+
+  async find() {
+    this._ensureActive()
+    try {
+      return await this._buildSelectQuery()
+    } finally {
+      this._destroy()
+    }
   }
 
   async get() {
+    // get 依赖 find，但因为 get 修改了 limit 状态，虽然 limit 方法没检测，
+    // 但最终调用的 find 会检测。为了保险起见，这里也可以不加 try/finally，
+    // 让 find 去处理销毁。
     this.limit(1)
-    const rows = await this.find()
+    const rows = await this.find() // find 会负责 destroy
     return rows.length > 0 ? rows[0] : null
   }
 
-  async count() {
-    const t = this.sql(this.tableName)
-
-    const w = this._buildWhere()
-    const ft = this.sql`${this.sql(this.schema)}.${t}`
-    const j = this._buildJoins()
-    
-    const r = await this.sql`SELECT count(*) as total FROM ${ft} ${j} ${w}`
-
-    if (r.length === 0) return 0
-
-    return parseInt(r[0].total)
-  }
-
-  async insert(data) {
-    const isArray = Array.isArray(data)
-    const inputs = isArray ? data : [data]
-    if (inputs.length === 0) throw new Error('[NeoPG] Insert data cannot be empty')
-
-    if (this.def) {
-      this._prepareDataForInsert(inputs)
-    }
-
-    const fullTable = this.sql`${this.sql(this.schema)}.${this.sql(this.tableName)}`
+  async findAndCount() {
+    this._ensureActive()
+    try {
+      // 1. 数据查询
+      const dataQuery = this._buildSelectQuery()
 
-    // [修改] 动态构建 returning
-    const retFragment = this._buildReturning()
+      // 2. 总数查询
+      const t = this.sql(this.tableName)
+      const w = this._buildWhere()
+      const j = this._buildJoins()
+      const g = this._buildGroup()
+      const ft = this.sql`${this.sql(this.schema)}.${t}`
+      
+      let countPromise
 
-    const result = await this.sql`INSERT INTO ${fullTable} ${this.sql(inputs)} ${retFragment}`
+      if (this._group.length > 0) {
+        countPromise = this.sql`SELECT count(*) as total FROM (SELECT 1 FROM ${ft} ${j} ${w} ${g}) as temp`
+      } else {
+        countPromise = this.sql`SELECT count(*) as total FROM ${ft} ${j} ${w}`
+      }
 
-    // 如果有 returning 数据，result 是数组（包含行）；否则 result 是 Result 对象（包含 count）
-    // 逻辑保持兼容：如果用户请求了数据，且是单条插入，返回对象；否则返回数组
-    if (this._returning && this._returning.length > 0) {
-        if (!isArray && result.length === 1) {
-          return result[0]
-        }
+      const [data, countResult] = await Promise.all([dataQuery, countPromise])
 
-        return result
+      return {
+        data,
+        total: parseInt(countResult[0]?.total || 0, 10)
+      }
+    } finally {
+      this._destroy()
     }
-    
-    // 如果没有 returning，返回 postgres 原生结果 (包含 count 等信息)
-    // 测试发现如果没有returning则返回的是空数组
-    return result
   }
 
-  async update(data) {
-    if (!data || Object.keys(data).length === 0) throw new Error('[NeoPG] Update data cannot be empty')
-    if (this.def) { this._prepareDataForUpdate(data) }
-    
-    if (this._conditions.length === 0) throw new Error('[NeoPG] UPDATE requires a WHERE condition')
-    
-    const fullTable = this.sql`${this.sql(this.schema)}.${this.sql(this.tableName)}`
-    // 修复：使用新方法构建
-    const whereFragment = this._buildWhere()
-    
-    // [修改] 动态构建 returning
-    const retFragment = this._buildReturning()
-    
-    const result = await this.sql`UPDATE ${fullTable} SET ${this.sql(data)} ${whereFragment} ${retFragment}`
-
-    if (this._returning && this._returning.length > 0) {
-        if (result.length === 1) return result[0]
-
-        return result
-    }
-
-    return result
-  }
-
-  async delete() {
-    if (this._conditions.length === 0) throw new Error('[NeoPG] DELETE requires a WHERE condition')
-    const fullTable = this.sql`${this.sql(this.schema)}.${this.sql(this.tableName)}`
-    // 修复：使用新方法构建
-    const whereFragment = this._buildWhere()
-    
-    const retFragment = this._buildReturning()
+  async count() {
+    this._ensureActive()
+    try {
+      const t = this.sql(this.tableName)
+      const w = this._buildWhere()
+      const j = this._buildJoins()
+      const g = this._buildGroup()
+      const ft = this.sql`${this.sql(this.schema)}.${t}`
       
-    return await this.sql`DELETE FROM ${fullTable} ${whereFragment} ${retFragment}`
-  }
-
-  async transaction(callback) {
-    return this.ctx.transaction(callback)
-    /* return await this.sql.begin(async (trxSql) => {
-      const scope = new TransactionScope(this.ctx, trxSql)
-      return await callback(scope)
-    }) */
-  }
-
-  begin(callback) {
-    return this.ctx.transaction(callback)
-  }
-
-   /**
-   * 内部通用 Join 添加器
-   * @param {string} type - 'INNER JOIN', 'LEFT JOIN', 'RIGHT JOIN'
-   * @param {string|Object} table - 表名 或 sql`fragment`
-   * @param {string|Object} on - 条件字符串 或 sql`fragment`
-   */
-  _addJoin(type, table, on) {
-    let tableFragment
-    let onFragment
-
-    // 1. 处理 Table
-    if (table.constructor && table.constructor.name === 'Query') {
-      tableFragment = table
-    } else {
-      // 默认作为当前 Schema 下的表名处理 "public"."table"
-      // 如果需要跨 Schema (e.g. "other.table")，请用户传入 sql`other.table`
-      tableFragment = this.sql(table)
-    }
+      let query;
+      if (this._group.length > 0) {
+        query = this.sql`SELECT count(*) as total FROM (SELECT 1 FROM ${ft} ${j} ${w} ${g}) as temp`
+      } else {
+        query = this.sql`SELECT count(*) as total FROM ${ft} ${j} ${w}`
+      }
 
-    // 2. 处理 ON 条件
-    if (on.constructor && on.constructor.name === 'Query') {
-      onFragment = on;
-    } else {
-      // 字符串情况，视为 Raw SQL (e.g. "u.id = p.uid")
-      // 因为 ON 条件通常包含操作符，无法简单参数化，必须 unsafe
-      onFragment = this.sql.unsafe(on);
+      const r = await query
+      if (r.length === 0) return 0
+      return parseInt(r[0].total)
+    } finally {
+      this._destroy()
     }
-
-    // 3. 构建单个 Join 片段
-    // 格式: TYPE + table + ON + condition
-    const joinFragment = this.sql`${this.sql.unsafe(type)} ${tableFragment} ON ${onFragment}`
-    
-    this._joins.push(joinFragment)
-    return this
-  }
-
-  join(table, on) {
-    return this._addJoin('INNER JOIN', table, on)
-  }
-
-  innerJoin(table, on) {
-    return this._addJoin('INNER JOIN', table, on)
-  }
-
-  leftJoin(table, on) {
-    return this._addJoin('LEFT JOIN', table, on)
   }
 
-  rightJoin(table, on) {
-    return this._addJoin('RIGHT JOIN', table, on)
-  }
-
-  fullJoin(table, on) {
-    return this._addJoin('FULL OUTER JOIN', table, on)
-  }
-
-  _buildJoins() {
-    const len = this._joins.length
-    if (len === 0) return this.sql``
+  async insert(data) {
+    this._ensureActive()
+    try {
+      const isArray = Array.isArray(data)
+      const inputs = isArray ? data : [data]
+      if (inputs.length === 0) throw new Error('[NeoPG] Insert data cannot be empty')
+
+      if (this.def) {
+        this._prepareDataForInsert(inputs)
+      }
 
-    // 只有一个 Join，直接返回
-    if (len === 1) {
-      return this._joins[0]
-    }
+      const fullTable = this.sql`${this.sql(this.schema)}.${this.sql(this.tableName)}`
+      const retFragment = this._buildReturning()
 
-    // 多个 Join，必须用空格连接，不能用逗号
-    // 采用“平铺数组”高性能方案
-    const parts = new Array(len * 2 - 1)
-    const SPACE = this.sql.unsafe(' ')
+      const result = await this.sql`INSERT INTO ${fullTable} ${this.sql(inputs)} ${retFragment}`
 
-    for (let i = 0; i < len; i++) {
-      parts[i * 2] = this._joins[i]
-      if (i < len - 1) {
-        parts[i * 2 + 1] = SPACE
+      if (this._returning && this._returning.length > 0) {
+          if (!isArray && result.length === 1) return result[0]
+          return result
       }
+      return result
+    } finally {
+      this._destroy()
     }
-
-    return this.sql`${parts}`
   }
 
-  /**
-   * 添加 Group By 条件
-   * .group('category_id')
-   * .group('category_id, type')
-   * .group(['id', 'name'])
-   */
-  group(arg) {
-    if (!arg) return this
-    
-    // 1. Fragment
-    if (arg.constructor && arg.constructor.name === 'Query') {
-      this._group.push(arg)
-      return this
-    }
-
-    // 2. Array
-    if (Array.isArray(arg)) {
-      arg.forEach(f => this.group(f))
-      return this
-    }
+  async update(data) {
+    this._ensureActive()
+    try {
+      if (!data || Object.keys(data).length === 0) throw new Error('[NeoPG] Update data cannot be empty')
+      if (this.def) { this._prepareDataForUpdate(data) }
+      if (this._conditions.length === 0) throw new Error('[NeoPG] UPDATE requires a WHERE condition')
+      
+      const fullTable = this.sql`${this.sql(this.schema)}.${this.sql(this.tableName)}`
+      const whereFragment = this._buildWhere()
+      const retFragment = this._buildReturning()
+      
+      const result = await this.sql`UPDATE ${fullTable} SET ${this.sql(data)} ${whereFragment} ${retFragment}`
 
-    // 3. String
-    if (typeof arg === 'string') {
-      if (arg.includes(',')) {
-        // 'id, name' -> 拆分
-        arg.split(',').map(s => s.trim()).filter(s=>s).forEach(s => {
-          this._group.push(this.sql(s))
-        })
-      } else {
-        // 单个字段
-        this._group.push(this.sql(arg))
+      if (this._returning && this._returning.length > 0) {
+          if (result.length === 1) return result[0]
+          return result
       }
+      return result
+    } finally {
+      this._destroy()
     }
-
-    return this
   }
 
-  // 构建 Group 片段
-  _buildGroup() {
-    if (this._group.length === 0) return this.sql``
-
-    // postgres.js 模板数组默认用逗号连接，正好符合 GROUP BY 语法
-    return this.sql`GROUP BY ${this._group}`
-  }
-
-  // --- 聚合函数 ---
-
-  async min(field) {
-    return this._aggregate('MIN', field)
-  }
-
-  async max(field) {
-    return this._aggregate('MAX', field)
-  }
-
-  async sum(field) {
-    return this._aggregate('SUM', field)
+  async delete() {
+    this._ensureActive()
+    try {
+      if (this._conditions.length === 0) throw new Error('[NeoPG] DELETE requires a WHERE condition')
+      const fullTable = this.sql`${this.sql(this.schema)}.${this.sql(this.tableName)}`
+      const whereFragment = this._buildWhere()
+      const retFragment = this._buildReturning()
+        
+      return await this.sql`DELETE FROM ${fullTable} ${whereFragment} ${retFragment}`
+    } finally {
+      this._destroy()
+    }
   }
 
-  async avg(field) {
-    return this._aggregate('AVG', field)
+  async transaction(callback) {
+    // 事务通常开启新的 Scope，不需要销毁当前 Chain
+    return this.ctx.transaction(callback)
   }
 
-  /**
-   * 通用聚合执行器
-   * @param {string} func - MIN, MAX, SUM, AVG
-   * @param {string} field - 列名
-   */
   async _aggregate(func, field) {
-    if (!field) throw new Error(`[NeoPG] ${func} requires a field name.`)
-
-    const t = this.sql(this.tableName)
-    const w = this._buildWhere()
-    const j = this._buildJoins()
-    const ft = this.sql`${this.sql(this.schema)}.${t}`
-
-    // 处理字段名 (可能是 'age' 也可能是 'users.age')
-    let colFragment;
-    if (field.constructor && field.constructor.name === 'Query') {
-        colFragment = field
-    } else {
-        colFragment = this.sql(field)
+    this._ensureActive()
+    try {
+        if (!field) throw new Error(`[NeoPG] ${func} requires a field name.`)
+
+        const t = this.sql(this.tableName)
+        const w = this._buildWhere()
+        const j = this._buildJoins()
+        const ft = this.sql`${this.sql(this.schema)}.${t}`
+
+        let colFragment;
+        if (field.constructor && field.constructor.name === 'Query') {
+            colFragment = field
+        } else {
+            colFragment = this.sql(field)
+        }
+        
+        const query = this.sql`
+            SELECT ${this.sql.unsafe(func)}(${colFragment}) as val 
+            FROM ${ft} ${j} ${w}
+        `
+
+        const result = await query
+        const val = result.length > 0 ? result[0].val : null
+        if (val === null) return null;
+        return this._convertAggregateValue(val, field, func)
+    } finally {
+        this._destroy()
     }
-    
-    // SELECT MIN(age) as val ...
-    const query = this.sql`
-        SELECT ${this.sql.unsafe(func)}(${colFragment}) as val 
-        FROM ${ft} ${j} ${w}
-    `
-
-    const result = await query
-    const val = result.length > 0 ? result[0].val : null
-
-    if (val === null) return null;
-
-    // 智能类型转换
-    return this._convertAggregateValue(val, field, func)
   }
 
-  /**
-   * 智能转换聚合结果类型
-   * Postgres 对于 SUM/AVG/COUNT 经常返回字符串 (BigInt/Numeric)，我们需要转回 Number
-   */
-  _convertAggregateValue(val, field, func) {
-    // 1. AVG 始终是浮点数
-    if (func === 'AVG') {
-      return parseFloat(val)
-    }
+  async min(field) { return this._aggregate('MIN', field) }
+  async max(field) { return this._aggregate('MAX', field) }
+  async sum(field) { return this._aggregate('SUM', field) }
+  async avg(field) { return this._aggregate('AVG', field) }
 
-    // 如果是 Raw Fragment，无法推断类型，直接返回原值（通常是 String）
+  _convertAggregateValue(val, field, func) {
+    if (func === 'AVG') return parseFloat(val)
     if (typeof field !== 'string') return val
 
-    // 2. 尝试从 ModelDef 获取列定义
-    // field 可能是 'age' 也可能是 'u.age' (别名暂不支持自动推断，这里只处理简单列名)
     const colDef = this.def && this.def.columns ? this.def.columns[field] : null
-
-    // 如果不知道列定义，尝试尽力猜测
     if (!colDef) {
-        // 如果 val 是字符串且长得像数字
         if (typeof val === 'string' && !isNaN(val)) {
-            // SUM 默认为数字
             if (func === 'SUM') return parseFloat(val)
         }
-
         return val
     }
 
-    // 5. [优化] 精确类型匹配
-    // 处理 'numeric(10,2)' -> 'numeric'
-    // 处理 'integer' -> 'integer'
     const rawType = colDef.type.toLowerCase()
     const parenIndex = rawType.indexOf('(')
     const baseType = parenIndex > 0 ? rawType.substring(0, parenIndex).trim() : rawType
 
-    // 整数匹配
-    if (INT_TYPES.has(baseType)) {
-      return parseInt(val, 10)
+    if (INT_TYPES.has(baseType)) return parseInt(val, 10)
+    if (FLOAT_TYPES.has(baseType)) return parseFloat(val)
+    return val
+  }
+
+  join(table, on) { return this._addJoin('INNER JOIN', table, on) }
+  innerJoin(table, on) { return this._addJoin('INNER JOIN', table, on) }
+  leftJoin(table, on) { return this._addJoin('LEFT JOIN', table, on) }
+  rightJoin(table, on) { return this._addJoin('RIGHT JOIN', table, on) }
+  fullJoin(table, on) { return this._addJoin('FULL OUTER JOIN', table, on) }
+
+  _addJoin(type, table, on) {
+    // 内部方法，不需要检测，提升性能
+    let tableFragment
+    let onFragment
+
+    if (table.constructor && table.constructor.name === 'Query') {
+      tableFragment = table
+    } else {
+      tableFragment = this.sql(table)
     }
 
-    // 浮点数匹配
-    if (FLOAT_TYPES.has(baseType)) {
-      return parseFloat(val)
+    if (on.constructor && on.constructor.name === 'Query') {
+      onFragment = on;
+    } else {
+      onFragment = this.sql.unsafe(on);
     }
 
-    // 其他 (Date, String, Boolean) 原样返回
-    return val
+    this._joins.push(this.sql`${this.sql.unsafe(type)} ${tableFragment} ON ${onFragment}`)
+    return this
   }
 
-  // --- 内部辅助方法 ---
-
+  // --- 数据预处理 ---
   _prepareDataForInsert(rows) {
     const pk = this.def.primaryKey
     const autoId = this.def.autoId
     const pkLen = this.def.pkLen
     const ts = this.def.timestamps
-    const defaults = this.def.defaults
 
     let make_timestamp = ts.insert && ts.insert.length > 0
 
@@ -606,13 +524,9 @@ class ModelChain {
       if (autoId && row[pk] === undefined) {
         row[pk] = this.def.makeId(pkLen)
       }
-
       if (make_timestamp) {
-        for (const t of ts.insert) {
-          makeTimestamp(row, t)
-        }
+        for (const t of ts.insert) makeTimestamp(row, t)
       }
-
       for (const key in row) {
         this.def.validateField(key, row[key])
       }
@@ -621,17 +535,13 @@ class ModelChain {
 
   _prepareDataForUpdate(row) {
     const ts = this.def.timestamps
-
     if (ts.update && ts.update.length > 0) {
-      for (const t of ts.update) {
-        makeTimestamp(row, t)
-      }
+      for (const t of ts.update) makeTimestamp(row, t)
     }
-
     for (const key in row) {
       this.def.validateField(key, row[key])
     }
   }
 }
 
-module.exports = ModelChain
+module.exports = ModelChain

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neopg",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "orm for postgres",
   "keywords": [
     "neopg",

package/test/test-db.js

@@ -213,7 +213,10 @@ db.add(User);
 
     if (n > 7) {
       console.error('\x1b[7;5m随机测试：将会让事物执行失败\x1b[0m')
-      await tx.model('User').insert({username: 'Neo'})
+      //await tx.model('User').insert({username: 'Neo'})
+      let subt = tx.model('User')
+      console.log('count', await subt.count())
+      console.log('count', await subt.count())
     }
 
     console.log('test count',