Looplan ORM是一个模仿ThinkPHP风格的TypeScript数据库操作库，提供简洁而强大的数据库操作API。

• 2025年11月5日: insertAll方法完善, update支持Db.raw()
• 2025年9月26日: 事务管理器增强(解决并发时事务冲突)
• 2025年7月5日: sql注入防护功能
• 2025年7月3日: 数据模型功能持续完善中
• 2025年6月30日: 连接池能力

npm install looplan-orm
# 安装依赖
npm install mysql2

在使用前需要先配置数据库连接信息：

import { databaseConfig } from 'looplan-orm';

// 设置配置
databaseConfig.setConfig({
    default: 'mysql',  // 默认连接
    connections: {
        mysql: {
            host: 'localhost',
            user: 'root',
            password: 'root',
            database: 'your_database',
            prefix: 'prefix_',  // 表前缀
        },
        mysql2: {
            host: 'localhost',
            user: 'root',
            password: 'root',
            database: 'your_second_database',
            prefix: 'prefix_',
        },
    },
});

import { Db } from 'looplan-orm';

// 查询单条记录
const result = await Db.table('user').where('id', 1).find();

// 查询多条记录
const results = await Db.table('user').select();

// 带条件查询
const users = await Db.table('user').where('status', 1).select();

// 指定字段查询
const result = await Db.table('user')
    .field('user.*, profile.nickname as user_nickname')
    .join('profile', 'user.id = profile.user_id')
    .select();

// 使用闭包组织复杂条件
const results = await Db.table('user').where(($query) => {
    $query.where('id', 1).where('status', 1);
}).select();

// 插入单条数据
const insertId = await Db.table('user').insert({
    name: 'test',
    age: 18,
    status: 1
});

// 插入并返回ID
const newId = await Db.table('user').insertGetId({
    name: 'test',
    age: 18,
    status: 1
});

// 批量插入
const result = await Db.table('user').insertAll([
    { name: 'user1', age: 18, status: 1 },
    { name: 'user2', age: 19, status: 1 },
    { name: 'user2', age: 19, status: 1, birthday: '2025-01-01' }, //支持不同的字段数量(会对比差异, 进行多次批量插入)
]);

// 更新数据
const affectedRows = await Db.table('user').where('id', 1).update({
    name: 'new name',
    age: 20
});

// 更新数据
const affectedRows = await Db.table('user').where('id', 1).update({
    name: 'new name',
    age: Db.raw('age + 1'), // 支持原始SQL表达式
});

// 删除数据
const affectedRows = await Db.table('user').where('id', 1).delete();

• 参数: where(字段名, 操作符, 值)
• 参数: where(条件组合)
• 参数: where(字段名, 值) 默认为等于操作符

// 基本条件
const results = await Db.table('user').where('id', 1).select();
// 最终生成sql: SELECT * FROM user WHERE id = 1

// 闭包条件
const results = await Db.table('user').where(($query) => {
    $query.where('id', 1).where('status', 1);
}).select();
// 最终生成sql: SELECT * FROM user WHERE (id = 1 AND status = 1)

• 参数: orWhere(条件组合)
• orWhere生成的条件会包裹在一个组里面

// 基础查询
const results = await Db.table('user').orWhere({
    id: 1,
    status: 1
}).select();

-- 最终生成sql
SELECT * FROM `user` WHERE (`id` = 1 OR `status` = 1)

• 多个组合条件

// 多个组合条件
const results2 = await Db.table('user').orWhere([
    {
        age: 12,
        status: 3,
    },
    {
        age: 14,
        status: 2,
    }
]).select();

-- 最终生成sql
SELECT * FROM `user` WHERE (
        (`age` = 12 AND `status` = 3) 
        OR 
        (`age` = 14 AND `status` = 2)
)

// 求和
const sum = await Db.table('user').sum('money');

// 计数
const count = await Db.table('user').count('id');

// 最大值
const max = await Db.table('user').max('age');

// 最小值
const min = await Db.table('user').min('age');

// 查询操作
const results = await Db.query('SELECT * FROM prefix_user WHERE id = ?', [1]);

// 执行更新操作
const affected = await Db.execute('UPDATE prefix_user SET name = ? WHERE id = ?', ['new name', 1]);

// 命名参数绑定
const results = await Db.query('SELECT * FROM prefix_user WHERE id = :id', { id: 1 });

事务基于请求ID, 并发执行时需要指定请求ID, 否则默认使用 'main' 作为请求ID

事务中对于多个数据库连接的情况,是每个数据库连接都会创建事务

import { Db, requestRun } from '../src';
import { randomUUID } from 'node:crypto';

// 生成请求ID
const reqId = randomUUID();
// 执行事务
async function testDbTransaction() {
  // 事务操作
  await Db.startTrans();
  try {
    const data1 = await Db.table('ct_test1').where('id', 1).find();
    console.log('事务中查询1:', data1);

    const data2 = await Db.table('ct_test1').where('id', 2).update({
      name: '事务更新测试' + Date.now()
    });
    console.log('事务中查询2:', data2);

    await Db.commit();
  } catch (error) {
    await Db.rollback();
    console.error('事务执行失败，已自动回滚:', error);
  }
}
// 执行请求(指定请求ID后, 并发执行不会冲突)
requestRun(reqId, async () => {
  await testDbTransaction();
});

// 自动管理事务
const result = await Db.transaction(async () => {
    const data1 = await Db.table('user').where('id', 1).find();
    const data2 = await Db.table('order').where('user_id', data1.id).select();
    
    return { user: data1, orders: data2 };
});

try {
    // 开始事务
    await Db.startTrans();
    
    // 执行查询和更新
    const user = await Db.table('user').where('id', 1).find();
    await Db.table('order').where('id', 100).update({ status: 'paid' });
    
    // 提交事务
    await Db.commit();
} catch (error) {
    // 发生错误时回滚
    await Db.rollback();
}

// 使用默认连接
const data1 = await Db.table('user').where('id', 1).find();

// 指定连接
const data2 = await Db.connect('mysql2').table('user').where('id', 1).find();

// 使用name方法（自动添加表前缀）
const data3 = await Db.name('user').where('id', 1).find();

// 获取即将执行的SQL语句
const sql = await Db.table('user')
    .where('status', 1)
    .fetchSql(true)  // 启用SQL获取模式
    .select();

console.log(sql);  // 输出SQL语句而不执行查询