@hazejs/orm 0.0.0-stage → 0.1.2

package/dist/index.mjs

@@ -0,0 +1,1067 @@
+import { _ as DatabaseError, a as Relation, b as translateDatabaseError, c as affectedRows, d as pascalCase, f as primaryKeyOf, g as useDatabaseManager, h as transaction, i as HasOne, l as isPlainObject, m as setDatabaseManager, n as BelongsTo, o as defaultKey, p as resolveSession, r as HasMany, s as loadRelations, t as ActiveRecord, u as nowFor, v as ModelNotFoundException, y as UniqueConstraintException } from "./record-DtkUCWRf.mjs";
+import { Hash, Logger, definePersistent, usePlatformBinding } from "@hazejs/core";
+import { mkdir, readFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import process from "node:process";
+import { SQL, and, asc, avg, between, count, desc, eq, getTableColumns, getTableName, gt, gte, inArray, is, isNotNull, isNull, like, lt, lte, max, min, ne, notBetween, notInArray, notLike, or, sql, sum } from "drizzle-orm";
+// src/auth.ts
+/**
+* 基于模型的用户来源（config/auth.ts 的 providers）：
+*
+* ```ts
+* providers: { users: modelUserProvider(() => User, { username: 'email' }) }
+* ```
+*
+* 模型以函数传入，避免配置文件与模型之间的循环导入。密码字段使用 `Hash.make()` 生成的哈希。
+*/
+function modelUserProvider(model, options = {}) {
+	const usernames = Array.isArray(options.username) ? options.username : [options.username ?? "email"];
+	const password = options.password ?? "password";
+	const statics = () => model();
+	return {
+		retrieveById: (id) => statics().find(id),
+		async retrieveByCredentials(credentials) {
+			const where = Object.fromEntries(usernames.filter((field) => credentials[field] !== void 0).map((field) => [field, credentials[field]]));
+			if (!Object.keys(where).length) return void 0;
+			return statics().where(where).find();
+		},
+		async validateCredentials(user, credentials) {
+			const hash = user[password];
+			const plain = credentials[password];
+			return typeof hash === "string" && typeof plain === "string" && Hash.verify(hash, plain);
+		},
+		getId: (user) => user.getKey()
+	};
+}
+// src/config.ts
+/** `config/database.ts` 的默认导出 */
+function defineDatabaseConfig(config) {
+	return config;
+}
+function dialectOf(driver) {
+	switch (driver) {
+		case "pglite": return "postgres";
+		case "turso":
+		case "d1": return "sqlite";
+		default: return driver;
+	}
+}
+// src/connection.ts
+/**
+* 连接跨 HMR 重载保留（同名且配置不变时复用），只在应用真正关闭时释放
+*/
+function connections() {
+	return definePersistent("orm:connections", () => /* @__PURE__ */ new Map(), { dispose: async (entries) => {
+		await Promise.all([...entries.values()].map(async (entry) => (await entry.connection.catch(() => void 0))?.close()));
+		entries.clear();
+	} });
+}
+var DatabaseManager = class {
+	config;
+	#options;
+	constructor(config, options = {}) {
+		if (!config?.connections || !config.default) throw new DatabaseError("Invalid database config: `default` and `connections` are required (config/database.ts)");
+		this.config = config;
+		this.#options = options;
+	}
+	get defaultConnection() {
+		return this.config.default;
+	}
+	connectionConfig(name = this.config.default) {
+		const config = this.config.connections[name];
+		if (!config) throw new DatabaseError(`Database connection "${name}" is not defined in config/database.ts`);
+		return config;
+	}
+	/** 获取连接（首次使用时建立） */
+	connection(name = this.config.default) {
+		const config = this.connectionConfig(name);
+		const hash = JSON.stringify(config);
+		const pool = connections();
+		const existing = pool.get(name);
+		if (existing?.hash === hash) return existing.connection;
+		existing?.connection.then((connection) => connection.close(), () => void 0);
+		const connection = openConnection(name, config, this.#options);
+		pool.set(name, {
+			hash,
+			connection
+		});
+		connection.catch(() => pool.get(name)?.connection === connection && pool.delete(name));
+		return connection;
+	}
+	/** 关闭连接（默认全部）；测试中可用于重建内存数据库 */
+	async close(name) {
+		const pool = connections();
+		const names = name ? [name] : [...pool.keys()];
+		for (const key of names) {
+			const entry = pool.get(key);
+			pool.delete(key);
+			await (await entry?.connection.catch(() => void 0))?.close();
+		}
+	}
+};
+async function openConnection(name, config, options) {
+	const logger = config.logging && options.logger ? { logQuery: (query, params) => options.logger.debug(`[db:${name}] ${query}`, params.length ? params : "") } : void 0;
+	const base = {
+		name,
+		driver: config.driver,
+		dialect: dialectOf(config.driver)
+	};
+	switch (config.driver) {
+		case "sqlite": {
+			const { createClient } = await importDriver("@libsql/client", () => import("@libsql/client"));
+			const { drizzle } = await import("drizzle-orm/libsql");
+			const client = createClient({
+				url: await sqliteUrl(config.url ?? "file:./data/app.db", options.rootDir),
+				authToken: config.authToken
+			});
+			return {
+				...base,
+				db: drizzle(client, { logger }),
+				close: async () => client.close()
+			};
+		}
+		case "turso": {
+			const { createClient } = await importDriver("@libsql/client", () => import("@libsql/client/web"));
+			const { drizzle } = await import("drizzle-orm/libsql/web");
+			if (!config.url) throw new DatabaseError(`Connection "${name}": url is required for turso (libsql:// or https://)`);
+			const client = createClient({
+				url: config.url,
+				authToken: config.authToken
+			});
+			return {
+				...base,
+				db: drizzle(client, { logger }),
+				close: async () => client.close()
+			};
+		}
+		case "d1": {
+			const { drizzle } = await import("drizzle-orm/d1");
+			const binding = typeof config.binding === "object" ? config.binding : usePlatformBinding(config.binding ?? "DB");
+			if (!binding) throw new DatabaseError(`Connection "${name}": D1 binding "${config.binding ?? "DB"}" not found. D1 is only available on Cloudflare Workers (preset cloudflare); use the sqlite driver locally`);
+			return {
+				...base,
+				db: drizzle(binding, { logger }),
+				close: async () => {}
+			};
+		}
+		case "postgres": {
+			const { default: postgres } = await importDriver("postgres", () => import("postgres"));
+			const { drizzle } = await import("drizzle-orm/postgres-js");
+			if (!config.url) throw new DatabaseError(`Connection "${name}": url is required for postgres`);
+			const client = postgres(config.url, {
+				max: config.pool ?? 10,
+				onnotice: () => {}
+			});
+			return {
+				...base,
+				db: drizzle(client, { logger }),
+				close: () => client.end()
+			};
+		}
+		case "pglite": {
+			const { PGlite } = await importDriver("@electric-sql/pglite", () => import("@electric-sql/pglite"));
+			const { drizzle } = await import("drizzle-orm/pglite");
+			const client = new PGlite(config.url);
+			return {
+				...base,
+				db: drizzle(client, { logger }),
+				close: () => client.close()
+			};
+		}
+		case "mysql": {
+			const mysql = await importDriver("mysql2", () => import("mysql2/promise"));
+			const { drizzle } = await import("drizzle-orm/mysql2");
+			if (!config.url) throw new DatabaseError(`Connection "${name}": url is required for mysql`);
+			const client = mysql.createPool({
+				uri: config.url,
+				connectionLimit: config.pool ?? 10
+			});
+			return {
+				...base,
+				db: drizzle(client, {
+					logger,
+					mode: "default"
+				}),
+				close: () => client.end()
+			};
+		}
+		case "mongodb": {
+			const { MongoClient } = await importDriver("mongodb", () => import("mongodb"));
+			if (!config.url) throw new DatabaseError(`Connection "${name}": url is required for mongodb`);
+			const client = new MongoClient(config.url, { maxPoolSize: config.pool ?? 10 });
+			await client.connect();
+			return {
+				...base,
+				db: client.db(config.database),
+				client,
+				close: () => client.close()
+			};
+		}
+		default: throw new DatabaseError(`Connection "${name}": unknown driver "${config.driver}"`);
+	}
+}
+/**
+* 加载驱动。导入路径须为字面量：打包器（Edge / 全量打包）据此静态解析驱动，
+* 未安装或该平台不支持的驱动在构建时替换为调用即报错的空模块。
+*/
+async function importDriver(pkg, load) {
+	try {
+		return await load();
+	} catch (error) {
+		throw new DatabaseError(`Database driver "${pkg}" could not be loaded. Install it with: pnpm add ${pkg}`, { cause: error });
+	}
+}
+/** file: 相对路径按项目根解析，并确保目录存在 */
+async function sqliteUrl(url, rootDir = process.cwd()) {
+	if (!url.startsWith("file:")) return url;
+	const path = url.slice(5);
+	const absolute = isAbsolute(path) ? path : resolve(rootDir, path);
+	await mkdir(dirname(absolute), { recursive: true });
+	return `file:${absolute}`;
+}
+// src/query/conditions.ts
+/** 条件构造：多次 where 以 AND 连接，orWhere 以 OR 连接（从左到右），回调参数用于分组 */
+var Conditions = class Conditions {
+	table;
+	parts = [];
+	constructor(table) {
+		this.table = table;
+	}
+	where(...args) {
+		return this.addCondition("and", args);
+	}
+	orWhere(...args) {
+		return this.addCondition("or", args);
+	}
+	whereIn(column, values) {
+		return this.pushCondition("and", inArray(this.columnOf(column), values));
+	}
+	whereNotIn(column, values) {
+		return this.pushCondition("and", notInArray(this.columnOf(column), values));
+	}
+	whereNull(column) {
+		return this.pushCondition("and", isNull(this.columnOf(column)));
+	}
+	whereNotNull(column) {
+		return this.pushCondition("and", isNotNull(this.columnOf(column)));
+	}
+	whereBetween(column, range) {
+		return this.pushCondition("and", between(this.columnOf(column), range[0], range[1]));
+	}
+	whereNotBetween(column, range) {
+		return this.pushCondition("and", notBetween(this.columnOf(column), range[0], range[1]));
+	}
+	whereLike(column, pattern) {
+		return this.pushCondition("and", like(this.columnOf(column), pattern));
+	}
+	whereNotLike(column, pattern) {
+		return this.pushCondition("and", notLike(this.columnOf(column), pattern));
+	}
+	/** 条件成立时才应用：`.when(keyword, q => q.whereLike('name', `%${keyword}%`))` */
+	when(value, callback) {
+		if (value !== void 0 && value !== null && value !== false && value !== "") callback(this, value);
+		return this;
+	}
+	/** 当前条件组合成的 SQL（无条件时为 undefined） */
+	buildWhere() {
+		let result;
+		for (const part of this.parts) result = result === void 0 ? part.sql : part.bool === "and" ? and(result, part.sql) : or(result, part.sql);
+		return result;
+	}
+	get hasConditions() {
+		return this.parts.length > 0;
+	}
+	/** 列名 → drizzle 列对象 */
+	columnOf(key) {
+		const column = getTableColumns(this.table)[key];
+		if (!column) throw new Error(`Unknown column "${key}" on table "${getTableName(this.table)}"`);
+		return column;
+	}
+	addCondition(bool, args) {
+		const condition = this.parseCondition(args);
+		return condition ? this.pushCondition(bool, condition) : this;
+	}
+	pushCondition(bool, sql) {
+		this.parts.push({
+			bool,
+			sql
+		});
+		return this;
+	}
+	parseCondition(args) {
+		if (args.length === 1) {
+			const [condition] = args;
+			if (typeof condition === "function") {
+				const group = new Conditions(this.table);
+				condition(group);
+				return group.buildWhere();
+			}
+			if (is(condition, SQL)) return condition;
+			if (isPlainObject(condition)) return and(...Object.entries(condition).map(([key, value]) => this.compare(key, "=", value)));
+			throw new TypeError("where() expects a column, an object, a drizzle SQL expression or a callback");
+		}
+		if (args.length === 2) return this.compare(args[0], "=", args[1]);
+		return this.compare(args[0], args[1], args[2]);
+	}
+	compare(key, operator, value) {
+		const column = this.columnOf(key);
+		switch (operator) {
+			case "=":
+				if (value === null) return isNull(column);
+				return Array.isArray(value) ? inArray(column, value) : eq(column, value);
+			case "!=":
+			case "<>":
+				if (value === null) return isNotNull(column);
+				return Array.isArray(value) ? notInArray(column, value) : ne(column, value);
+			case ">": return gt(column, value);
+			case ">=": return gte(column, value);
+			case "<": return lt(column, value);
+			case "<=": return lte(column, value);
+			case "like": return like(column, value);
+			case "not like": return notLike(column, value);
+			case "in": return inArray(column, value);
+			case "not in": return notInArray(column, value);
+			case "between": return between(column, value[0], value[1]);
+			case "not between": return notBetween(column, value[0], value[1]);
+			default: throw new Error(`Unsupported operator "${String(operator)}"`);
+		}
+	}
+};
+// src/query/builder.ts
+/**
+* ThinkPHP 风格的查询构造器，底层使用 drizzle：
+*
+* ```ts
+* await Db.table(users).where('status', 1).order('id', 'desc').paginate(1, 20)
+* ```
+*/
+var QueryBuilder = class extends Conditions {
+	connectionName;
+	orders = [];
+	limitValue;
+	offsetValue;
+	fields;
+	constructor(table, options = {}) {
+		super(table);
+		this.connectionName = options.connection;
+	}
+	/** 切换连接 */
+	connection(name) {
+		this.connectionName = name;
+		return this;
+	}
+	order(column, direction = "asc") {
+		if (is(column, SQL)) this.orders.push(column);
+		else if (typeof column === "string") this.orders.push(direction === "desc" ? desc(this.columnOf(column)) : asc(this.columnOf(column)));
+		else for (const [key, dir] of Object.entries(column)) this.order(key, dir ?? "asc");
+		return this;
+	}
+	limit(value) {
+		this.limitValue = value;
+		return this;
+	}
+	offset(value) {
+		this.offsetValue = value;
+		return this;
+	}
+	/** 分页：page 从 1 开始 */
+	page(page, perPage = 15) {
+		return this.limit(perPage).offset((Math.max(1, page) - 1) * perPage);
+	}
+	/** 只查询指定列 */
+	field(...keys) {
+		this.fields = keys;
+		return this;
+	}
+	/** 查询全部结果 */
+	async select() {
+		const session = await this.session();
+		const selection = this.fields ? Object.fromEntries(this.fields.map((key) => [key, this.columnOf(key)])) : void 0;
+		let query = (selection ? session.db.select(selection) : session.db.select()).from(this.table).$dynamic();
+		const where = this.scopedWhere();
+		if (where) query = query.where(where);
+		if (this.orders.length) query = query.orderBy(...this.orders);
+		if (this.limitValue !== void 0) query = query.limit(this.limitValue);
+		if (this.offsetValue !== void 0) query = query.offset(this.offsetValue);
+		return this.transform(await query);
+	}
+	/** 查询第一条，不存在时为 undefined */
+	async find() {
+		const [first] = await this.clone().limit(1).select();
+		return first;
+	}
+	async findOrFail() {
+		const result = await this.find();
+		if (result === void 0) throw new ModelNotFoundException(this.label());
+		return result;
+	}
+	/** 某一列的值（第一条） */
+	async value(column) {
+		return (await this.clone().field(column).find())?.[column];
+	}
+	/** 某一列的全部值 */
+	async column(column) {
+		return (await this.clone().field(column).select()).map((row) => row[column]);
+	}
+	async count() {
+		return Number(await this.aggregate(count()) ?? 0);
+	}
+	async sum(column) {
+		return Number(await this.aggregate(sum(this.columnOf(column))) ?? 0);
+	}
+	async avg(column) {
+		const value = await this.aggregate(avg(this.columnOf(column)));
+		return value === null || value === void 0 ? null : Number(value);
+	}
+	async max(column) {
+		return await this.aggregate(max(this.columnOf(column)));
+	}
+	async min(column) {
+		return await this.aggregate(min(this.columnOf(column)));
+	}
+	async exists() {
+		return await this.count() > 0;
+	}
+	async paginate(page = 1, perPage = 15) {
+		const current = Math.max(1, Math.floor(page));
+		const total = await this.count();
+		return {
+			data: await this.clone().page(current, perPage).select(),
+			total,
+			page: current,
+			perPage,
+			lastPage: Math.max(1, Math.ceil(total / perPage))
+		};
+	}
+	/** 分批处理大量数据，回调返回 false 时停止 */
+	async chunk(size, callback) {
+		for (let page = 1;; page++) {
+			const rows = await this.clone().page(page, size).select();
+			if (!rows.length || await callback(rows, page) === false || rows.length < size) return;
+		}
+	}
+	/** 插入一条或多条，返回插入后的完整记录（MySQL 通过主键回查） */
+	async insert(values) {
+		const list = Array.isArray(values) ? values : [values];
+		if (!list.length) return [];
+		const session = await this.session();
+		const query = session.db.insert(this.table).values(list);
+		if (session.dialect !== "mysql") return this.write(() => query.returning());
+		const key = primaryKeyOf(this.table);
+		const ids = await this.write(() => query.$returningId());
+		if (!key || !ids.length) return [];
+		return session.db.select().from(this.table).where(inArray(this.columnOf(key), ids.map((id) => id[key])));
+	}
+	/** 插入一条并返回主键值 */
+	async insertGetId(values) {
+		const key = primaryKeyOf(this.table);
+		if (!key) throw new DatabaseError(`Table "${getTableName(this.table)}" has no single-column primary key`);
+		const [row] = await this.insert(values);
+		return row?.[key];
+	}
+	/** 按当前条件更新，返回影响行数 */
+	async update(values, options = {}) {
+		const where = this.writableWhere("update", options);
+		const session = await this.session();
+		return affectedRows(await this.write(() => session.db.update(this.table).set(values).where(where)));
+	}
+	/** 按当前条件删除，返回影响行数 */
+	async delete(options = {}) {
+		const where = this.writableWhere("delete", options);
+		const session = await this.session();
+		return affectedRows(await this.write(() => session.db.delete(this.table).where(where)));
+	}
+	async increment(column, step = 1) {
+		const target = this.columnOf(column);
+		return this.update({ [column]: sql`${target} + ${step}` });
+	}
+	async decrement(column, step = 1) {
+		const target = this.columnOf(column);
+		return this.update({ [column]: sql`${target} - ${step}` });
+	}
+	/** 生成的 SQL 与参数（调试用） */
+	async toSQL() {
+		let query = (await this.session()).db.select().from(this.table).$dynamic();
+		const where = this.scopedWhere();
+		if (where) query = query.where(where);
+		if (this.orders.length) query = query.orderBy(...this.orders);
+		if (this.limitValue !== void 0) query = query.limit(this.limitValue);
+		if (this.offsetValue !== void 0) query = query.offset(this.offsetValue);
+		return query.toSQL();
+	}
+	clone() {
+		const copy = Object.create(Object.getPrototypeOf(this));
+		Object.assign(copy, this);
+		copy.parts = [...this.parts];
+		copy.orders = [...this.orders];
+		copy.fields = this.fields && [...this.fields];
+		return copy;
+	}
+	/** 子类（ModelQuery）追加的全局条件，例如软删除 */
+	scopedWhere() {
+		return this.buildWhere();
+	}
+	/** 子类（ModelQuery）把行转换为模型 */
+	async transform(rows) {
+		return rows;
+	}
+	label() {
+		return getTableName(this.table);
+	}
+	session() {
+		return resolveSession(this.connectionName);
+	}
+	async aggregate(expression) {
+		let query = (await this.session()).db.select({ value: expression }).from(this.table).$dynamic();
+		const where = this.scopedWhere();
+		if (where) query = query.where(where);
+		const [row] = await query;
+		return row?.value;
+	}
+	/** 写操作：把唯一约束等数据库错误转换为框架异常（409） */
+	async write(run) {
+		try {
+			return await run();
+		} catch (error) {
+			throw translateDatabaseError(error);
+		}
+	}
+	writableWhere(action, options) {
+		const where = this.scopedWhere();
+		if (!where && !options.all) throw new DatabaseError(`Refusing to ${action} all rows of "${getTableName(this.table)}" without conditions. Pass { all: true } to confirm.`);
+		return where;
+	}
+};
+/** 将多个条件以 AND 合并（忽略 undefined） */
+function andAll(...conditions) {
+	const defined = conditions.filter((condition) => condition !== void 0);
+	return defined.length > 1 ? and(...defined) : defined[0];
+}
+// src/db.ts
+/** 执行原生 SQL，统一返回行数组 */
+async function execute(query, connection) {
+	const { db, dialect } = await resolveSession(connection);
+	if (dialect === "sqlite") return db.all(query);
+	const result = await db.execute(query);
+	if (dialect === "mysql") return result[0];
+	return Array.isArray(result) ? result : result.rows;
+}
+function scoped(connection) {
+	return {
+		/** 查询构造器：`Db.table(users).where('id', 1).find()` */
+		table: (table) => new QueryBuilder(table, { connection }),
+		/** 事务（回调内的 Db / Model 查询自动加入事务，嵌套使用保存点） */
+		transaction: (callback) => transaction(callback, connection),
+		/** 原生 SQL：`Db.execute(sql\`select 1\`)` */
+		execute: (query) => execute(query, connection),
+		/** 底层 drizzle 实例（处于事务中时为事务对象），用于 join 等复杂查询 */
+		drizzle: async () => (await resolveSession(connection)).db
+	};
+}
+/** 数据库门面：默认连接的快捷入口，`Db.connection(name)` 切换连接 */
+const Db = {
+	...scoped(),
+	connection: (name) => scoped(name)
+};
+// src/migrate.ts
+/**
+* 执行 drizzle-kit 生成的迁移（已执行过的会跳过）。迁移记录与 drizzle 自带的迁移器相同，
+* 可与 drizzle-kit migrate 混用。
+*/
+async function migrate(options) {
+	const manager = options.manager ?? useDatabaseManager();
+	const migrations = await readMigrations(options.folder, options.files);
+	const connection = await manager.connection(options.connection);
+	if (connection.driver === "mongodb") throw new DatabaseError(`Connection "${connection.name}" is MongoDB, which has no SQL migrations; manage indexes with Mongo.collection().createIndex()`);
+	const before = await appliedCount(connection);
+	const { db } = connection;
+	switch (connection.driver) {
+		case "sqlite":
+		case "turso":
+			await migrateSqlite(db, migrations, (statements) => db.session.migrate(statements));
+			break;
+		case "d1":
+			await migrateSqlite(db, migrations, async (statements) => statements.length && db.session.batch(statements), true);
+			break;
+		default: await db.dialect.migrate(migrations, db.session, { migrationsFolder: options.folder });
+	}
+	return {
+		connection: connection.name,
+		folder: options.folder,
+		applied: await appliedCount(connection) - before,
+		total: migrations.length
+	};
+}
+/** 迁移目录（相对后端源码目录）：连接配置的 migrations，默认连接为 database/migrations，其它为 database/migrations/<name> */
+function migrationsFolder(name, manager = useDatabaseManager()) {
+	const connection = name ?? manager.defaultConnection;
+	return (manager.connectionConfig(connection).migrations ?? (connection === manager.defaultConnection ? "database/migrations" : `database/migrations/${connection}`)).replace(/^\.\//, "").replace(/\/+$/, "");
+}
+/**
+* 按 config/database.ts 执行迁移：`haze db:migrate` 与生产构建的迁移入口
+* （`node dist/server/migrate.mjs`、Lambda 的 `index.migrate`）共用。
+*/
+async function runMigrations(options = {}) {
+	const manager = options.manager ?? useDatabaseManager();
+	const names = options.all ? Object.keys(manager.config.connections) : [options.connection ?? manager.defaultConnection];
+	const results = [];
+	for (const name of names) {
+		const relative = migrationsFolder(name, manager);
+		if (manager.connectionConfig(name).driver === "mongodb") {
+			results.push({
+				connection: name,
+				folder: relative,
+				skipped: "mongodb"
+			});
+			continue;
+		}
+		const folder = options.files || isAbsolute(relative) ? relative : resolve(options.srcDir ?? process.cwd(), relative);
+		if (!await readFile$1(journalPath(folder), options.files)) {
+			if (!options.all) throw new DatabaseError(`No migrations for connection "${name}" in ${relative}. Run haze db:generate first.`);
+			results.push({
+				connection: name,
+				folder: relative,
+				skipped: "no-migrations"
+			});
+			continue;
+		}
+		results.push({
+			...await migrate({
+				connection: name,
+				folder,
+				files: options.files,
+				manager
+			}),
+			folder: relative
+		});
+	}
+	return results;
+}
+/** 与 drizzle 的 readMigrationFiles 相同的解析（哈希为整个文件的 SHA-256），可读取内嵌文件 */
+async function readMigrations(folder, files) {
+	const journal = await readFile$1(journalPath(folder), files);
+	if (journal === void 0) throw new DatabaseError(`Migrations not found in ${folder} (meta/_journal.json is missing). Run haze db:generate first.`);
+	const entries = [];
+	for (const entry of JSON.parse(journal).entries) {
+		const query = await readFile$1(`${trimSlash(folder)}/${entry.tag}.sql`, files);
+		if (query === void 0) throw new DatabaseError(`Migration file ${entry.tag}.sql not found in ${folder}`);
+		entries.push({
+			sql: query.split("--> statement-breakpoint"),
+			bps: entry.breakpoints,
+			folderMillis: entry.when,
+			hash: await sha256(query)
+		});
+	}
+	return entries;
+}
+/** 与 drizzle 的 libsql / d1 迁移器相同：一次批量执行全部未运行的迁移 */
+async function migrateSqlite(db, migrations, execute, literal = false) {
+	const table = sql.identifier("__drizzle_migrations");
+	await db.session.run(sql`CREATE TABLE IF NOT EXISTS ${table} (id SERIAL PRIMARY KEY, hash text NOT NULL, created_at numeric)`);
+	const [last] = await db.values(sql`SELECT id, hash, created_at FROM ${table} ORDER BY created_at DESC LIMIT 1`);
+	const statements = [];
+	for (const migration of migrations) {
+		if (last && Number(last[2]) >= migration.folderMillis) continue;
+		for (const statement of migration.sql) statements.push(db.run(sql.raw(statement)));
+		statements.push(db.run(literal ? sql`INSERT INTO ${table} ("hash", "created_at") VALUES(${sql.raw(`'${migration.hash}'`)}, ${sql.raw(String(migration.folderMillis))})` : sql`INSERT INTO ${table} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`));
+	}
+	await execute(statements);
+}
+/** 已执行的迁移数（迁移表不存在时为 0） */
+async function appliedCount(connection) {
+	const table = connection.dialect === "postgres" ? sql`"drizzle"."__drizzle_migrations"` : sql`${sql.identifier("__drizzle_migrations")}`;
+	const query = sql`select count(*) as n from ${table}`;
+	const { db } = connection;
+	try {
+		const result = connection.dialect === "sqlite" ? await db.all(query) : await db.execute(query);
+		const rows = connection.dialect === "mysql" ? result[0] : Array.isArray(result) ? result : result.rows;
+		return Number(rows[0]?.n ?? 0);
+	} catch {
+		return 0;
+	}
+}
+async function readFile$1(path, files) {
+	if (files) return files[path];
+	return readFile(path, "utf8").catch(() => void 0);
+}
+function journalPath(folder) {
+	return `${trimSlash(folder)}/meta/_journal.json`;
+}
+function trimSlash(path) {
+	return path.replace(/\/+$/, "");
+}
+async function sha256(text) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+// src/model/meta.ts
+const cache = /* @__PURE__ */ new WeakMap();
+/** 解析并缓存模型元数据（主键、软删除列、时间戳列） */
+function metaOf(model) {
+	const cached = cache.get(model);
+	if (cached) return cached;
+	if (!model.table) throw new DatabaseError(`Model ${model.name} has no table. Use: class ${model.name} extends Model.define(table) {}`);
+	const columns = getTableColumns(model.table);
+	const pick = (key, fallback, required) => {
+		if (key === false) return void 0;
+		const name = key ?? fallback;
+		if (name in columns) return name;
+		if (required || key) throw new DatabaseError(`Model ${model.name}: column "${name}" does not exist on table "${getTableName(model.table)}"`);
+	};
+	const timestamps = model.timestamps === false ? {
+		createdAt: false,
+		updatedAt: false
+	} : model.timestamps === true ? {} : model.timestamps;
+	const meta = {
+		table: model.table,
+		tableName: getTableName(model.table),
+		columns,
+		primaryKey: primaryKeyOf(model.table),
+		softDelete: model.softDelete ? pick(typeof model.softDelete === "string" ? model.softDelete : void 0, "deletedAt", true) : void 0,
+		createdAt: pick(timestamps.createdAt, "createdAt", false),
+		updatedAt: pick(timestamps.updatedAt, "updatedAt", false)
+	};
+	cache.set(model, meta);
+	return meta;
+}
+// src/model/query.ts
+/** 模型查询：结果为模型实例，自动应用软删除范围，支持预加载关联与作用域 */
+var ModelQuery = class extends QueryBuilder {
+	model;
+	trashed = "without";
+	eager = [];
+	constructor(model) {
+		super(metaOf(model).table, { connection: model.connection });
+		this.model = model;
+	}
+	/** 包含已软删除的数据 */
+	withTrashed() {
+		this.trashed = "with";
+		return this;
+	}
+	/** 只查询已软删除的数据 */
+	onlyTrashed() {
+		this.trashed = "only";
+		return this;
+	}
+	/** 预加载关联：`with('posts', 'posts.comments', 'profile')` */
+	with(...relations) {
+		this.eager.push(...relations);
+		return this;
+	}
+	/** 调用模型上的 `static scopeXxx(query, ...args)`：`scope('active')` */
+	scope(name, ...args) {
+		const method = this.model[`scope${pascalCase(name)}`];
+		if (typeof method !== "function") throw new TypeError(`Scope "${name}" is not defined on ${this.model.name} (expected static scope${pascalCase(name)}(query))`);
+		method.call(this.model, this, ...args);
+		return this;
+	}
+	/** 按主键查询；不传主键时取第一条 */
+	async find(id) {
+		if (id === void 0) return super.find();
+		return this.clone().where(this.primaryKey(), id).limit(1).select().then((rows) => rows[0]);
+	}
+	async findOrFail(id) {
+		const model = await this.find(id);
+		if (!model) throw new ModelNotFoundException(this.model.name, id);
+		return model;
+	}
+	paginate(page = 1, perPage = 15) {
+		return super.paginate(page, perPage);
+	}
+	/** 批量删除：启用软删除时只标记删除时间 */
+	async delete(options = {}) {
+		const { softDelete, columns } = metaOf(this.model);
+		if (softDelete && this.trashed !== "only") return this.update({ [softDelete]: nowFor(columns[softDelete]) }, options);
+		return super.delete(options);
+	}
+	/** 物理删除（忽略软删除） */
+	async forceDelete(options = {}) {
+		return super.delete(options);
+	}
+	/** 恢复软删除的数据 */
+	async restore(options = {}) {
+		const { softDelete } = metaOf(this.model);
+		if (!softDelete) return 0;
+		return this.withTrashed().update({ [softDelete]: null }, options);
+	}
+	scopedWhere() {
+		const { softDelete } = metaOf(this.model);
+		if (!softDelete || this.trashed === "with") return this.buildWhere();
+		const column = this.columnOf(softDelete);
+		return andAll(this.buildWhere(), this.trashed === "only" ? isNotNull(column) : isNull(column));
+	}
+	async transform(rows) {
+		const models = rows.map((row) => hydrateModel(this.model, row));
+		if (this.eager.length) await loadRelations(models, this.eager);
+		return models;
+	}
+	label() {
+		return this.model.name;
+	}
+	clone() {
+		const copy = super.clone();
+		copy.eager = [...this.eager];
+		return copy;
+	}
+	primaryKey() {
+		const key = metaOf(this.model).primaryKey;
+		if (!key) throw new Error(`Model ${this.model.name} has no single-column primary key`);
+		return key;
+	}
+};
+// src/model/model.ts
+/**
+* ThinkPHP 风格模型，表结构来自 drizzle：
+*
+* ```ts
+* export class User extends Model.define(users) {
+*   static override softDelete = true
+*   static override hidden = ['password']
+*
+*   posts() {
+*     return this.hasMany(Post, 'userId')
+*   }
+*
+*   static scopeActive(query: ModelQuery<User>) {
+*     query.where('status', 1)
+*   }
+* }
+*
+* const user = await User.findOrFail(1)
+* user.name = 'Ada'
+* await user.save()
+* await User.where('status', 1).with('posts').order('id', 'desc').paginate(1, 20)
+* ```
+*
+* 访问器 / 修改器：定义 `getNameAttr(value, data)` / `setNameAttr(value, data)`；
+* 事件：定义 `onBeforeInsert()`、`onAfterUpdate()` 等方法。
+*/
+var Model = class extends ActiveRecord {
+	/** 使用的连接名，默认使用 config/database.ts 的 default */
+	static connection = void 0;
+	/** 软删除：true 使用 deletedAt 列，或指定列名 */
+	static softDelete = false;
+	/** 自动维护 createdAt / updatedAt（列存在时），可指定列名或设为 false */
+	static timestamps = true;
+	/** 声明模型对应的表：`class User extends Model.define(users) {}` */
+	static define(table) {
+		class Defined extends Model {
+			static table = table;
+		}
+		for (const key of Object.keys(getTableColumns(table))) Object.defineProperty(Defined.prototype, key, {
+			get() {
+				return this.getAttr(key);
+			},
+			set(value) {
+				this.setAttr(key, value);
+			},
+			configurable: true,
+			enumerable: false
+		});
+		return Defined;
+	}
+	static primaryKeyName() {
+		return metaOf(this).primaryKey;
+	}
+	static query() {
+		return new ModelQuery(this);
+	}
+	static where(...args) {
+		return new ModelQuery(this).where(...args);
+	}
+	static whereIn(column, values) {
+		return new ModelQuery(this).whereIn(column, values);
+	}
+	static order(column, direction = "asc") {
+		return new ModelQuery(this).order(column, direction);
+	}
+	static with(...relations) {
+		return new ModelQuery(this).with(...relations);
+	}
+	static scope(name, ...args) {
+		return new ModelQuery(this).scope(name, ...args);
+	}
+	static withTrashed() {
+		return new ModelQuery(this).withTrashed();
+	}
+	static onlyTrashed() {
+		return new ModelQuery(this).onlyTrashed();
+	}
+	static find(id) {
+		return new ModelQuery(this).find(id);
+	}
+	static findOrFail(id) {
+		return new ModelQuery(this).findOrFail(id);
+	}
+	static all() {
+		return new ModelQuery(this).select();
+	}
+	static paginate(page, perPage) {
+		return new ModelQuery(this).paginate(page, perPage);
+	}
+	static count() {
+		return new ModelQuery(this).count();
+	}
+	/** 创建并保存（会触发事件与时间戳） */
+	static async create(data) {
+		const model = new this();
+		const record = model;
+		record.fill(data);
+		await record.save();
+		return model;
+	}
+	/** 按主键删除（逐个触发事件与软删除），返回删除数量 */
+	static async destroy(ids) {
+		const list = Array.isArray(ids) ? ids : [ids];
+		const models = list.length ? await new ModelQuery(this).whereIn(defaultKey(this), list).select() : [];
+		for (const model of models) await model.delete();
+		return models.length;
+	}
+	/** 新模型插入，已存在模型更新修改过的字段 */
+	async save() {
+		const meta = this.#meta();
+		await this.runHook("onBeforeWrite");
+		if (!this.$exists) {
+			await this.runHook("onBeforeInsert");
+			for (const key of [meta.createdAt, meta.updatedAt]) if (key && this.$attributes[key] == null) this.$attributes[key] = nowFor(meta.columns[key]);
+			const [row] = await this.#builder().insert(pickColumns(this.$attributes, meta.columns));
+			if (row) this.$attributes = {
+				...this.$attributes,
+				...row
+			};
+			this.$exists = true;
+			this.syncOriginal();
+			await this.runHook("onAfterInsert");
+		} else {
+			const dirty = pickColumns(this.getDirty(), meta.columns);
+			if (Object.keys(dirty).length) {
+				await this.runHook("onBeforeUpdate");
+				if (meta.updatedAt && !(meta.updatedAt in dirty)) dirty[meta.updatedAt] = this.$attributes[meta.updatedAt] = nowFor(meta.columns[meta.updatedAt]);
+				await this.#whereKey().update(dirty);
+				this.syncOriginal();
+				await this.runHook("onAfterUpdate");
+			}
+		}
+		await this.runHook("onAfterWrite");
+		return this;
+	}
+	/** 删除：启用软删除时只标记删除时间 */
+	async delete() {
+		if (!this.$exists) return false;
+		const meta = this.#meta();
+		await this.runHook("onBeforeDelete");
+		if (meta.softDelete) {
+			const value = nowFor(meta.columns[meta.softDelete]);
+			await this.#whereKey().update({ [meta.softDelete]: value });
+			this.$attributes[meta.softDelete] = value;
+			this.$original[meta.softDelete] = value;
+		} else {
+			await this.#whereKey().delete();
+			this.$exists = false;
+		}
+		await this.runHook("onAfterDelete");
+		return true;
+	}
+	/** 物理删除 */
+	async forceDelete() {
+		if (!this.$exists) return false;
+		await this.runHook("onBeforeDelete");
+		await this.#whereKey().delete();
+		this.$exists = false;
+		await this.runHook("onAfterDelete");
+		return true;
+	}
+	/** 恢复软删除 */
+	async restore() {
+		const { softDelete } = this.#meta();
+		if (!softDelete) return this;
+		await this.runHook("onBeforeRestore");
+		await this.#whereKey().update({ [softDelete]: null });
+		this.$attributes[softDelete] = null;
+		this.$original[softDelete] = null;
+		await this.runHook("onAfterRestore");
+		return this;
+	}
+	trashed() {
+		const { softDelete } = this.#meta();
+		return softDelete ? this.$attributes[softDelete] != null : false;
+	}
+	/** 从数据库重新读取 */
+	async refresh() {
+		const row = await this.#whereKey().find();
+		if (!row) throw new DatabaseError(`${this.constructor.name} ${String(this.getKey())} no longer exists`);
+		this.$attributes = { ...row };
+		this.syncOriginal();
+		return this;
+	}
+	acceptsAttribute(key) {
+		return key in this.#meta().columns;
+	}
+	#meta() {
+		return metaOf(this.constructor);
+	}
+	#builder() {
+		const model = this.constructor;
+		return new QueryBuilder(model.table, { connection: model.connection });
+	}
+	#whereKey() {
+		const key = this.#meta().primaryKey;
+		if (!key) throw new DatabaseError(`${this.constructor.name} has no single-column primary key`);
+		return this.#builder().where(key, this.$original[key] ?? this.$attributes[key]);
+	}
+};
+/** 由数据库行构造模型（供 ModelQuery 使用） */
+function hydrateModel(model, row) {
+	return Model.hydrate.call(model, row);
+}
+function pickColumns(values, columns) {
+	return Object.fromEntries(Object.entries(values).filter(([key]) => key in columns));
+}
+// src/provider.ts
+/**
+* 数据库服务提供者（放在 app/provider/DatabaseProvider.ts）：
+*
+* ```ts
+* export default databaseProvider()
+* ```
+*
+* 注册 DatabaseManager（可 inject），并让 Db / Model 使用该配置。连接在首次查询时建立，
+* 开发时跨热更新复用，应用关闭时释放。
+*/
+function databaseProvider(options = {}) {
+	return { register(container, app) {
+		const input = options.config ?? app.config.get("database", void 0);
+		if (!input) throw new Error("databaseProvider(): config/database.ts is missing");
+		const manager = new DatabaseManager(typeof input === "function" ? input() : input, {
+			logger: container.make(Logger),
+			rootDir: app.rootDir
+		});
+		container.instance(DatabaseManager, manager);
+		setDatabaseManager(manager);
+	} };
+}
+// src/testing.ts
+/**
+* 测试用：重建连接并执行迁移。配合 `.env.test` 中的 `DATABASE_URL=:memory:`，每个用例得到全新的数据库。
+*
+* ```ts
+* const t = useTestApp()
+* beforeEach(() => refreshDatabase())
+* ```
+*/
+async function refreshDatabase(options = {}) {
+	const manager = useDatabaseManager();
+	const name = options.connection ?? manager.defaultConnection;
+	if (manager.connectionConfig(name).driver === "mongodb") {
+		await (await manager.connection(name)).db.dropDatabase();
+		return;
+	}
+	await manager.close(name);
+	await migrate({
+		manager,
+		connection: options.connection,
+		folder: resolve(process.cwd(), options.migrations ?? "database/migrations")
+	});
+}
+export { ActiveRecord, BelongsTo, Conditions, DatabaseError, DatabaseManager, Db, HasMany, HasOne, Model, ModelNotFoundException, ModelQuery, QueryBuilder, Relation, UniqueConstraintException, databaseProvider, defineDatabaseConfig, dialectOf, migrate, migrationsFolder, modelUserProvider, refreshDatabase, resolveSession, runMigrations, setDatabaseManager, transaction, translateDatabaseError, useDatabaseManager };