neopg 0.0.0 → 1.0.0

package/lib/ModelChain.js

@@ -1,7 +1,20 @@
-'use strict';
+'use strict'
 
-const makeId = require('./makeId.js');
-const makeTimestamp = require('./makeTimestamp.js');
+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',
+    'int2', 'int4', 'int8'
+])
+
+const FLOAT_TYPES = new Set([
+    'float', 'double', 'numeric', 'decimal', 'real', 
+    'money', 'double precision', 'float4', 'float8'
+])
 
 /**
  * ModelChain - 链式查询构建器
@@ -29,6 +42,9 @@ class ModelChain {
     this._columns = null
     this._group = null
     this._lock = null
+    this._returning = null
+    this._joins = []
+    this._group = []
 
     // 内部状态标记
     this._isRaw = !!def.isRaw
@@ -50,68 +66,54 @@ class ModelChain {
    * 3. .where('age', '>', 18) -> age > 18 (兼容)
    */
   where(arg1, arg2, arg3) {
-    if (!arg1) return this
-
-    // 1. 识别 Postgres Fragment (Query)
-    // 依据指令：直接检测构造函数名称是否为 'Query'
-    if (arg1.constructor && arg1.constructor.name === 'Query') {
+      if (!arg1) return this
+      // 1. Fragment 检测
+      if (arg1.constructor && arg1.constructor.name === 'Query') {
         this._conditions.push(arg1)
         return this
-    }
-
-    // 2. 对象写法 .where({ id: 1, name: 'Neo' })
-    if (typeof arg1 === 'object' && !Array.isArray(arg1)) {
-      const keys = Object.keys(arg1)
-      if (keys.length === 0) return this
-
-      for (const key of keys) {
-        const val = arg1[key];
-        if (val === undefined) continue
-        
-        if (val === null) {
-           this._conditions.push(this.sql`${this.sql(key)} IS NULL`)
-        } else if (Array.isArray(val)) {
-           this._conditions.push(this.sql`${this.sql(key)} IN ${this.sql(val)}`)
-        } else {
-           this._conditions.push(this.sql`${this.sql(key)} = ${val}`)
-        }
       }
+      
+      // 2. Object 写法
+      if (typeof arg1 === 'object' && !Array.isArray(arg1)) {
+        for (const k of Object.keys(arg1)) {
+          const v = arg1[k]
 
-      return this
-    }
+          if (v === undefined) continue
 
-    // 3. 字符串/参数写法
-    if (typeof arg1 === 'string') {
-      // Case A: .where('id', 123)  => id = 123 (默认等于)
-      if (arg2 !== undefined && arg3 === undefined) {
-        this._conditions.push(this.sql`${this.sql(arg1)} = ${arg2}`)
-        return this
-      }
-      
-      // Case B: .where('age', '>', 18)
-      if (arg3 !== undefined) {
-        // 注意：中间的操作符必须用 sql.unsafe，因为它不是变量
-        this._conditions.push(this.sql`${this.sql(arg1)} ${this.sql.unsafe(arg2)} ${arg3}`)
+          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
       }
 
-      // Case C: .where('id = ?', 123) (简单兼容)
-      if (arg1.includes('?') && arg2 !== undefined) {
-        const parts = arg1.split('?')
-
-        // 只支持单个参数简单替换，复杂的请用 sql``
-        if (parts.length === 2) {
-           this._conditions.push(this.sql`${this.sql.unsafe(parts[0])}${arg2}${this.sql.unsafe(parts[1])}`)
-           return this
-        }
+      // 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))
       }
-      
-      // Case D: 纯字符串 (视为 Raw SQL)
-      // .where("status = 'active'")
-      this._conditions.push(this.sql.unsafe(arg1))
-    }
 
-    return this
+      return this
   }
 
   whereIf(condition, arg1, arg2, arg3) {
@@ -131,43 +133,29 @@ class ModelChain {
     return this
   }
 
-  /**
-   * 排序
-   * .order(sql`create_time DESC`)
-   * .order('create_time', 'DESC')
-   * .order({ create_time: 'DESC' })
-   */
-  order(arg1, arg2) {
-    if (!arg1) return this
-
-    // 1. Fragment
-    if (arg1.constructor && arg1.constructor.name === 'Query') {
-      this._order.push(arg1)
-      return this
-    }
+  orderby(a, b) {
+      if(!a) return this
 
-    // 2. Object { id: 'DESC' }
-    if (typeof arg1 === 'object') {
-      for (const key in arg1) {
-        const dir = arg1[key].toUpperCase()
-        this._order.push(this.sql`${this.sql(key)} ${this.sql.unsafe(dir)}`)
+      if(a.constructor && a.constructor.name==='Query') {
+        this._order.push(a)
+        return this
       }
 
-      return this
-    }
+      if(typeof a==='object') {
+        for(const k in a) {
+          this._order.push(this.sql`${this.sql(k)} ${this.sql.unsafe(a[k].toUpperCase())}`)
+        }
+        
+        return this
+      }
 
-    // 3. String ('id', 'DESC')
-    if (typeof arg1 === 'string') {
-      const dir = arg2 ? arg2.toUpperCase() : 'ASC'
-      // 检查 arg1 是否包含空格 (e.g. "id desc")
-      if (arg1.includes(' ')) {
-        this._order.push(this.sql.unsafe(arg1))
-      } else {
-        this._order.push(this.sql`${this.sql(arg1)} ${this.sql.unsafe(dir)}`)
+      if(typeof a==='string') {
+        const d = b ? b.toUpperCase() : 'ASC'
+        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
+      return this
   }
 
   limit(count, offset = 0) {
@@ -190,49 +178,91 @@ class ModelChain {
     return this
   }
 
-  // --- 核心：执行方法 ---
+  returning(cols) {
+    if (!cols) return this
 
-  async find() {
-    const tableFragment = this.sql(this.tableName)
+    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
+    }
+
+    return this
+  }
 
-    const colsFragment = this._columns 
-        ? this.sql(this._columns) 
-        : this.sql`*`
+  // --- 构建 RETURNING 片段 ---
+  _buildReturning() {
+    // 如果没有设置 returning，默认不返回数据 (节省性能)
+    // 注意：这意味着默认 insert/update 返回的是 Result 对象(包含 count)，而不是行数据
+    if (!this._returning || this._returning.length === 0) {
+        return this.sql``
+    }
 
-    const whereFragment = this._conditions.length 
-        ? this.sql`WHERE ${this.sql(this._conditions, ' AND ')}` 
-        : this.sql``
+    // 特殊处理 '*': 用户显式要求 returning('*')
+    // 如果直接用 this.sql(['*']) 会被转义为 "*"，导致错误
+    if (this._returning.length === 1 && this._returning[0] === '*') {
+        return this.sql`RETURNING *`
+    }
 
-    const orderFragment = this._order.length 
-        ? this.sql`ORDER BY ${this.sql(this._order)}` 
-        : this.sql``
-        
-    const limitFragment = this._limit 
-        ? this.sql`LIMIT ${this._limit}` 
-        : this.sql``
-        
-    const offsetFragment = this._offset 
-        ? this.sql`OFFSET ${this._offset}` 
-        : this.sql``
+    // 普通字段：利用 postgres.js 自动转义标识符
+    return this.sql`RETURNING ${this.sql(this._returning)}`
+  }
+
+   // --- 辅助：构建 Where 片段 (修复 Bug 的核心) ---
+  _buildWhere() {
+    const len = this._conditions.length
+    if (len === 0) return this.sql``
     
-    const lockFragment = this._lock || this.sql``
-
-    const fullTable = this.sql`${this.sql(this.schema)}.${tableFragment}`
-
-    return await this.sql`
-      SELECT ${colsFragment} 
-      FROM ${fullTable}
-      ${whereFragment}
-      ${orderFragment}
-      ${limitFragment}
-      ${offsetFragment}
-      ${lockFragment}
-    `
+    // 只有一个条件，直接返回，零开销
+    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
+      }
+    }
+
+    // postgres.js 会自动展开这个扁平数组，性能极高
+    return this.sql`WHERE ${parts}`
+  }
+
+  // --- 辅助：构建 Order 片段 (修复 Bug) ---
+  _buildOrder() {
+    if (this._order.length === 0) return this.sql``
+    // 数组直接传入模板，postgres.js 默认用逗号连接，这正是 ORDER BY 需要的
+    // 不能用 this.sql(this._order)，那样会试图转义为标识符
+    return this.sql`ORDER BY ${this._order}`
   }
 
-  // Thenable 接口
-  then(onFulfilled, onRejected) {
-    return this.find().then(onFulfilled, onRejected)
+  // --- 核心：执行方法 ---
+
+  async find() {
+    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()
+    const g = this._buildGroup()
+
+    const l = this._limit ? this.sql`LIMIT ${this._limit}` : this.sql``
+    const off = this._offset ? this.sql`OFFSET ${this._offset}` : this.sql``
+    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}`
   }
 
   async get() {
@@ -242,22 +272,19 @@ class ModelChain {
   }
 
   async count() {
-    const tableFragment = this.sql(this.tableName);
-    const whereFragment = this._conditions.length 
-        ? this.sql`WHERE ${this.sql(this._conditions, ' AND ')}` 
-        : this.sql``
+    const t = this.sql(this.tableName)
+
+    const w = this._buildWhere()
+    const ft = this.sql`${this.sql(this.schema)}.${t}`
+    const j = this._buildJoins()
     
-    const fullTable = this.sql`${this.sql(this.schema)}.${tableFragment}`
+    const r = await this.sql`SELECT count(*) as total FROM ${ft} ${j} ${w}`
 
-    const result = await this.sql`
-        SELECT count(*) as total FROM ${fullTable} ${whereFragment}
-    `
+    if (r.length === 0) return 0
 
-    return parseInt(result[0].total)
+    return parseInt(r[0].total)
   }
 
-  // --- 写入方法 ---
-
   async insert(data) {
     const isArray = Array.isArray(data)
     const inputs = isArray ? data : [data]
@@ -269,53 +296,299 @@ class ModelChain {
 
     const fullTable = this.sql`${this.sql(this.schema)}.${this.sql(this.tableName)}`
 
-    const result = await this.sql`
-      INSERT INTO ${fullTable} ${this.sql(inputs)}
-      RETURNING *
-    `
+    // [修改] 动态构建 returning
+    const retFragment = this._buildReturning()
+
+    const result = await this.sql`INSERT INTO ${fullTable} ${this.sql(inputs)} ${retFragment}`
 
-    if (!isArray && result.length > 0) return result[0]
+    // 如果有 returning 数据，result 是数组（包含行）；否则 result 是 Result 对象（包含 count）
+    // 逻辑保持兼容：如果用户请求了数据，且是单条插入，返回对象；否则返回数组
+    if (this._returning && this._returning.length > 0) {
+        if (!isArray && result.length === 1) {
+          return result[0]
+        }
 
+        return result
+    }
+    
+    // 如果没有 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.def) {
-      this._prepareDataForUpdate(data)
-    }
+    if (this._returning && this._returning.length > 0) {
+        if (result.length === 1) return result[0]
 
-    if (this._conditions.length === 0) {
-        throw new Error('[NeoPG] UPDATE requires a WHERE condition')
+        return result
     }
 
-    const fullTable = this.sql`${this.sql(this.schema)}.${this.sql(this.tableName)}`
-    const whereFragment = this.sql`WHERE ${this.sql(this._conditions, ' AND ')}`
-
-    // 使用 sql(data) 自动处理 set a=1, b=2
-    return await this.sql`
-      UPDATE ${fullTable}
-      SET ${this.sql(data)}
-      ${whereFragment}
-      RETURNING *
-    `
+    return result
   }
 
   async delete() {
-    if (this._conditions.length === 0) {
-        throw new Error('[NeoPG] DELETE requires a WHERE condition')
+    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}`
+  }
+
+  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)
     }
 
-    const fullTable = this.sql`${this.sql(this.schema)}.${this.sql(this.tableName)}`
+    // 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);
+    }
+
+    // 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``
+
+    // 只有一个 Join，直接返回
+    if (len === 1) {
+      return this._joins[0]
+    }
+
+    // 多个 Join，必须用空格连接，不能用逗号
+    // 采用“平铺数组”高性能方案
+    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}`
+  }
+
+  /**
+   * 添加 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
+    }
 
-    const whereFragment = this.sql`WHERE ${this.sql(this._conditions, ' AND ')}`
+    // 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))
+      }
+    }
+
+    return this
+  }
 
-    return await this.sql`
-      DELETE FROM ${fullTable}
-      ${whereFragment}
-      RETURNING *
+  // 构建 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 avg(field) {
+    return this._aggregate('AVG', field)
+  }
+
+  /**
+   * 通用聚合执行器
+   * @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)
+    }
+    
+    // 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)
+    }
+
+    // 如果是 Raw Fragment，无法推断类型，直接返回原值（通常是 String）
+    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 (FLOAT_TYPES.has(baseType)) {
+      return parseFloat(val)
+    }
+
+    // 其他 (Date, String, Boolean) 原样返回
+    return val
   }
 
   // --- 内部辅助方法 ---