@hazejs/orm 0.0.0-stage → 0.1.2

package/dist/mongo/index.d.mts

@@ -0,0 +1,21 @@
+import { B as DefinedMongoModel, F as MongoModelQuery, G as MongoModelSettings, H as MongoModel, I as MongoQuery, J as MongoSession, K as hydrateMongoModel, L as MongoQueryOptions, R as MongoWhere, U as MongoModelClass, V as DocOf, W as MongoModelMeta, X as resolveMongo, Y as mongoTransaction, q as metaOfMongo, z as toObjectId } from "../model-CBky_ILK.mjs";
+import { ClientSession, Db, Document, ObjectId } from "mongodb";
+export interface ScopedMongo {
+  /** 集合查询构造器：`Mongo.collection<UserDoc>('users').where('status', 1).select()` */
+  collection: <T extends Document = Document>(name: string) => MongoQuery<T>;
+  /** 事务（需要副本集）：回调内的 Mongo / MongoModel 操作自动加入事务 */
+  transaction: <R>(callback: (session: ClientSession) => Promise<R>) => Promise<R>;
+  /** 底层 mongodb Db 实例（索引管理、变更流等） */
+  db: () => Promise<Db>;
+}
+/** MongoDB 门面：默认连接的快捷入口，`Mongo.connection(name)` 切换连接 */
+export declare const Mongo: {
+  connection: (name: string) => ScopedMongo;
+  /** 集合查询构造器：`Mongo.collection<UserDoc>('users').where('status', 1).select()` */
+  collection: <T extends Document = Document>(name: string) => MongoQuery<T>;
+  /** 事务（需要副本集）：回调内的 Mongo / MongoModel 操作自动加入事务 */
+  transaction: <R>(callback: (session: ClientSession) => Promise<R>) => Promise<R>;
+  /** 底层 mongodb Db 实例（索引管理、变更流等） */
+  db: () => Promise<Db>;
+};
+export { type DefinedMongoModel, type DocOf, MongoModel, type MongoModelClass, type MongoModelMeta, MongoModelQuery, type MongoModelSettings, MongoQuery, type MongoQueryOptions, type MongoSession, type MongoWhere, ObjectId, hydrateMongoModel, metaOfMongo, mongoTransaction, resolveMongo, toObjectId };

package/dist/mongo/index.mjs

@@ -0,0 +1,630 @@
+import { _ as DatabaseError, b as translateDatabaseError, d as pascalCase, g as useDatabaseManager, l as isPlainObject, s as loadRelations, t as ActiveRecord, v as ModelNotFoundException } from "../record-DtkUCWRf.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { ObjectId, ObjectId as ObjectId$1 } from "mongodb";
+// src/mongo/context.ts
+/** 事务会话：连接名 → ClientSession（与 SQL 事务一样隐式传播） */
+const sessions = new AsyncLocalStorage();
+async function resolveMongo(connection) {
+	const resolved = await useDatabaseManager().connection(connection);
+	if (resolved.dialect !== "mongodb") throw new DatabaseError(`Connection "${resolved.name}" uses driver "${resolved.driver}", not mongodb`);
+	return {
+		name: resolved.name,
+		db: resolved.db,
+		client: resolved.client,
+		session: sessions.getStore()?.get(resolved.name)
+	};
+}
+/**
+* MongoDB 事务（需要副本集或分片集群）。回调内的 Mongo / MongoModel 操作自动加入事务；
+* MongoDB 不支持嵌套事务，嵌套调用直接复用外层事务。
+*/
+async function mongoTransaction(callback, connection) {
+	const mongo = await resolveMongo(connection);
+	if (mongo.session) return callback(mongo.session);
+	const session = mongo.client.startSession();
+	try {
+		let result;
+		await session.withTransaction(async () => {
+			result = await sessions.run(new Map(sessions.getStore()).set(mongo.name, session), () => callback(session));
+		});
+		return result;
+	} finally {
+		await session.endSession();
+	}
+}
+// src/mongo/model.ts
+/** 解析软删除与时间戳字段（文档无固定结构，按配置决定） */
+function metaOfMongo(model) {
+	const timestamps = model.timestamps === false ? {
+		createdAt: false,
+		updatedAt: false
+	} : model.timestamps === true ? {} : model.timestamps;
+	return {
+		softDelete: model.softDelete ? typeof model.softDelete === "string" ? model.softDelete : "deletedAt" : void 0,
+		createdAt: timestamps.createdAt === false ? void 0 : timestamps.createdAt ?? "createdAt",
+		updatedAt: timestamps.updatedAt === false ? void 0 : timestamps.updatedAt ?? "updatedAt"
+	};
+}
+/**
+* MongoDB 模型，API 与 SQL 的 Model 一致：
+*
+* ```ts
+* interface UserDoc { name: string, email: string, status: number }
+*
+* export class User extends MongoModel.define<UserDoc>('users') {
+*   static override softDelete = true
+*   posts() {
+*     return this.hasMany(Post, 'userId')
+*   }
+* }
+*
+* const user = await User.findOrFail('6650…')   // 字符串 _id 自动转为 ObjectId
+* await User.where('status', 1).with('posts').paginate(1, 20)
+* ```
+*/
+var MongoModel = class extends ActiveRecord {
+	static connection = void 0;
+	/** 软删除：true 使用 deletedAt 字段，或指定字段名 */
+	static softDelete = false;
+	/** 自动维护 createdAt / updatedAt，可指定字段名或设为 false */
+	static timestamps = true;
+	constructor() {
+		super();
+		return new Proxy(this, {
+			get(target, property, receiver) {
+				if (typeof property === "symbol" || property in target) return Reflect.get(target, property, receiver);
+				return target.getAttr(property);
+			},
+			set(target, property, value, receiver) {
+				if (typeof property === "symbol" || property in target) return Reflect.set(target, property, value, receiver);
+				target.setAttr(property, value);
+				return true;
+			}
+		});
+	}
+	/** 声明模型对应的集合：`class User extends MongoModel.define<UserDoc>('users') {}` */
+	static define(collection) {
+		class Defined extends MongoModel {
+			static collection = collection;
+		}
+		return Defined;
+	}
+	static primaryKeyName() {
+		return "_id";
+	}
+	static query() {
+		return new MongoModelQuery(this);
+	}
+	static where(...args) {
+		return new MongoModelQuery(this).where(...args);
+	}
+	static whereIn(field, values) {
+		return new MongoModelQuery(this).whereIn(field, values);
+	}
+	static order(field, direction = "asc") {
+		return new MongoModelQuery(this).order(field, direction);
+	}
+	static with(...relations) {
+		return new MongoModelQuery(this).with(...relations);
+	}
+	static scope(name, ...args) {
+		return new MongoModelQuery(this).scope(name, ...args);
+	}
+	static withTrashed() {
+		return new MongoModelQuery(this).withTrashed();
+	}
+	static onlyTrashed() {
+		return new MongoModelQuery(this).onlyTrashed();
+	}
+	static find(id) {
+		return new MongoModelQuery(this).find(id);
+	}
+	static findOrFail(id) {
+		return new MongoModelQuery(this).findOrFail(id);
+	}
+	static all() {
+		return new MongoModelQuery(this).select();
+	}
+	static paginate(page, perPage) {
+		return new MongoModelQuery(this).paginate(page, perPage);
+	}
+	static count() {
+		return new MongoModelQuery(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 MongoModelQuery(this).whereIn("_id", 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");
+			const now = /* @__PURE__ */ new Date();
+			for (const key of [meta.createdAt, meta.updatedAt]) if (key && this.$attributes[key] == null) this.$attributes[key] = now;
+			const id = await this.$query().insertGetId(this.$attributes);
+			this.$attributes._id = id;
+			this.$exists = true;
+			this.syncOriginal();
+			await this.runHook("onAfterInsert");
+		} else {
+			const { _id: _ignored, ...dirty } = this.getDirty();
+			if (Object.keys(dirty).length) {
+				await this.runHook("onBeforeUpdate");
+				if (meta.updatedAt && !(meta.updatedAt in dirty)) dirty[meta.updatedAt] = this.$attributes[meta.updatedAt] = /* @__PURE__ */ new Date();
+				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 { softDelete } = this.$meta();
+		await this.runHook("onBeforeDelete");
+		if (softDelete) {
+			const now = /* @__PURE__ */ new Date();
+			await this.$whereKey().update({ [softDelete]: now });
+			this.$attributes[softDelete] = now;
+			this.$original[softDelete] = now;
+		} 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 doc = await this.$whereKey().find();
+		if (!doc) throw new DatabaseError(`${this.constructor.name} ${String(this.getKey())} no longer exists`);
+		this.$attributes = { ...doc };
+		this.syncOriginal();
+		return this;
+	}
+	/** 文档主键（ObjectId） */
+	get id() {
+		return this.$attributes._id;
+	}
+	$meta() {
+		return metaOfMongo(this.constructor);
+	}
+	$query() {
+		const model = this.constructor;
+		return new MongoQuery(model.collection, { connection: model.connection });
+	}
+	$whereKey() {
+		return this.$query().where("_id", this.$attributes._id);
+	}
+};
+/** 由文档构造模型（供 MongoModelQuery 使用） */
+function hydrateMongoModel(model, doc) {
+	return MongoModel.hydrate.call(model, doc);
+}
+// src/mongo/query.ts
+/** 把字符串形式的 _id 转为 ObjectId（其它字段原样保留） */
+function toObjectId(value) {
+	return typeof value === "string" && ObjectId$1.isValid(value) && value.length === 24 ? new ObjectId$1(value) : value;
+}
+/** SQL LIKE 模式 → 正则：% 任意长度，_ 单个字符 */
+function likeToRegex(pattern) {
+	const source = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".");
+	return new RegExp(`^${source}$`);
+}
+/**
+* MongoDB 查询构造器，方法与 SQL 的 Db.table() 一致：
+*
+* ```ts
+* await Mongo.collection<UserDoc>('users').where('status', 1).order('createdAt', 'desc').paginate(1, 20)
+* ```
+*
+* Mongo 特有能力：`aggregate(pipeline)`、`where({ tags: { $all: ['a'] } })` 直接使用查询运算符。
+*/
+var MongoQuery = class MongoQuery {
+	collectionName;
+	connectionName;
+	parts = [];
+	sorts = [];
+	limitValue;
+	offsetValue;
+	fields;
+	constructor(collection, options = {}) {
+		this.collectionName = collection;
+		this.connectionName = options.connection;
+	}
+	connection(name) {
+		this.connectionName = name;
+		return this;
+	}
+	where(...args) {
+		return this.addCondition("and", args);
+	}
+	orWhere(...args) {
+		return this.addCondition("or", args);
+	}
+	whereIn(field, values) {
+		return this.pushCondition("and", { [field]: { $in: this.normalizeList(field, values) } });
+	}
+	whereNotIn(field, values) {
+		return this.pushCondition("and", { [field]: { $nin: this.normalizeList(field, values) } });
+	}
+	/** 字段为 null 或不存在 */
+	whereNull(field) {
+		return this.pushCondition("and", { [field]: null });
+	}
+	whereNotNull(field) {
+		return this.pushCondition("and", { [field]: { $ne: null } });
+	}
+	whereBetween(field, range) {
+		return this.pushCondition("and", { [field]: {
+			$gte: range[0],
+			$lte: range[1]
+		} });
+	}
+	whereNotBetween(field, range) {
+		return this.pushCondition("and", { $or: [{ [field]: { $lt: range[0] } }, { [field]: { $gt: range[1] } }] });
+	}
+	/** SQL 风格的 LIKE 模式（% 与 _），区分大小写 */
+	whereLike(field, pattern) {
+		return this.pushCondition("and", { [field]: { $regex: likeToRegex(pattern) } });
+	}
+	whereNotLike(field, pattern) {
+		return this.pushCondition("and", { [field]: { $not: likeToRegex(pattern) } });
+	}
+	when(value, callback) {
+		if (value !== void 0 && value !== null && value !== false && value !== "") callback(this, value);
+		return this;
+	}
+	/** 当前条件组成的过滤器 */
+	buildFilter() {
+		let result;
+		for (const part of this.parts) result = result === void 0 ? part.filter : { [part.bool === "and" ? "$and" : "$or"]: [result, part.filter] };
+		return result ?? {};
+	}
+	get hasConditions() {
+		return this.parts.length > 0;
+	}
+	order(field, direction = "asc") {
+		if (typeof field === "string") this.sorts.push([field, direction === "desc" ? -1 : 1]);
+		else for (const [key, dir] of Object.entries(field)) this.order(key, dir ?? "asc");
+		return this;
+	}
+	limit(value) {
+		this.limitValue = value;
+		return this;
+	}
+	offset(value) {
+		this.offsetValue = value;
+		return this;
+	}
+	page(page, perPage = 15) {
+		return this.limit(perPage).offset((Math.max(1, page) - 1) * perPage);
+	}
+	field(...fields) {
+		this.fields = fields;
+		return this;
+	}
+	async select() {
+		const mongo = await this.session();
+		const cursor = mongo.db.collection(this.collectionName).find(this.scopedFilter(), {
+			session: mongo.session,
+			projection: this.fields ? Object.fromEntries(this.fields.map((field) => [field, 1])) : void 0,
+			sort: this.sorts.length ? this.sorts : void 0,
+			skip: this.offsetValue,
+			limit: this.limitValue
+		});
+		return this.transform(await cursor.toArray());
+	}
+	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(field) {
+		return (await this.clone().field(field).find())?.[field];
+	}
+	async column(field) {
+		return (await this.clone().field(field).select()).map((doc) => doc[field]);
+	}
+	async count() {
+		const mongo = await this.session();
+		return mongo.db.collection(this.collectionName).countDocuments(this.scopedFilter(), { session: mongo.session });
+	}
+	async sum(field) {
+		return Number(await this.group({ $sum: `$${field}` }) ?? 0);
+	}
+	async avg(field) {
+		const value = await this.group({ $avg: `$${field}` });
+		return value === null || value === void 0 ? null : Number(value);
+	}
+	async max(field) {
+		return await this.group({ $max: `$${field}` }) ?? null;
+	}
+	async min(field) {
+		return await this.group({ $min: `$${field}` }) ?? null;
+	}
+	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))
+		};
+	}
+	async chunk(size, callback) {
+		for (let page = 1;; page++) {
+			const docs = await this.clone().page(page, size).select();
+			if (!docs.length || await callback(docs, page) === false || docs.length < size) return;
+		}
+	}
+	/** 聚合管道（自动在开头加上当前条件的 $match） */
+	async aggregate(pipeline) {
+		const mongo = await this.session();
+		const filter = this.scopedFilter();
+		const stages = Object.keys(filter).length ? [{ $match: filter }, ...pipeline] : pipeline;
+		return mongo.db.collection(this.collectionName).aggregate(stages, { session: mongo.session }).toArray();
+	}
+	/** 插入一条或多条，返回带 _id 的文档 */
+	async insert(docs) {
+		const list = (Array.isArray(docs) ? docs : [docs]).map((doc) => ({ ...doc }));
+		if (!list.length) return [];
+		const mongo = await this.session();
+		const result = await this.write(() => mongo.db.collection(this.collectionName).insertMany(list, { session: mongo.session }));
+		return list.map((doc, index) => ({
+			...doc,
+			_id: result.insertedIds[index]
+		}));
+	}
+	async insertGetId(doc) {
+		const [inserted] = await this.insert(doc);
+		return inserted._id;
+	}
+	/** 按条件更新（普通字段使用 $set，也可直接传 $inc / $push 等运算符），返回匹配数量 */
+	async update(values, options = {}) {
+		const filter = this.writableFilter("update", options);
+		const update = Object.keys(values).some((key) => key.startsWith("$")) ? values : { $set: values };
+		const mongo = await this.session();
+		return (await this.write(() => mongo.db.collection(this.collectionName).updateMany(filter, update, { session: mongo.session }))).matchedCount;
+	}
+	async delete(options = {}) {
+		const filter = this.writableFilter("delete", options);
+		const mongo = await this.session();
+		return (await this.write(() => mongo.db.collection(this.collectionName).deleteMany(filter, { session: mongo.session }))).deletedCount;
+	}
+	increment(field, step = 1) {
+		return this.update({ $inc: { [field]: step } });
+	}
+	decrement(field, step = 1) {
+		return this.update({ $inc: { [field]: -step } });
+	}
+	/** 生成的过滤器（调试用） */
+	toFilter() {
+		return this.scopedFilter();
+	}
+	clone() {
+		const copy = Object.create(Object.getPrototypeOf(this));
+		Object.assign(copy, this);
+		copy.parts = [...this.parts];
+		copy.sorts = [...this.sorts];
+		copy.fields = this.fields && [...this.fields];
+		return copy;
+	}
+	scopedFilter() {
+		return this.buildFilter();
+	}
+	async transform(docs) {
+		return docs;
+	}
+	label() {
+		return this.collectionName;
+	}
+	session() {
+		return resolveMongo(this.connectionName);
+	}
+	pushCondition(bool, filter) {
+		this.parts.push({
+			bool,
+			filter
+		});
+		return this;
+	}
+	addCondition(bool, args) {
+		const filter = this.parseCondition(args);
+		return filter ? this.pushCondition(bool, filter) : this;
+	}
+	parseCondition(args) {
+		if (args.length === 1) {
+			const [condition] = args;
+			if (typeof condition === "function") {
+				const group = new MongoQuery(this.collectionName);
+				condition(group);
+				return group.hasConditions ? group.buildFilter() : void 0;
+			}
+			if (isPlainObject(condition)) {
+				const entries = Object.entries(condition).map(([field, value]) => this.compare(field, "=", value));
+				return entries.length > 1 ? { $and: entries } : entries[0];
+			}
+			throw new TypeError("where() expects a field, an object or a callback");
+		}
+		if (args.length === 2) return this.compare(args[0], "=", args[1]);
+		return this.compare(args[0], args[1], args[2]);
+	}
+	compare(field, operator, raw) {
+		const value = this.normalize(field, raw);
+		switch (operator) {
+			case "=":
+				if (Array.isArray(value)) return { [field]: { $in: this.normalizeList(field, value) } };
+				return { [field]: value };
+			case "!=":
+			case "<>": return { [field]: Array.isArray(value) ? { $nin: this.normalizeList(field, value) } : { $ne: value } };
+			case ">": return { [field]: { $gt: value } };
+			case ">=": return { [field]: { $gte: value } };
+			case "<": return { [field]: { $lt: value } };
+			case "<=": return { [field]: { $lte: value } };
+			case "like": return { [field]: { $regex: likeToRegex(String(raw)) } };
+			case "not like": return { [field]: { $not: likeToRegex(String(raw)) } };
+			case "in": return { [field]: { $in: this.normalizeList(field, raw) } };
+			case "not in": return { [field]: { $nin: this.normalizeList(field, raw) } };
+			case "between": return { [field]: {
+				$gte: raw[0],
+				$lte: raw[1]
+			} };
+			case "not between": return { $or: [{ [field]: { $lt: raw[0] } }, { [field]: { $gt: raw[1] } }] };
+			default: throw new Error(`Unsupported operator "${String(operator)}"`);
+		}
+	}
+	normalize(field, value) {
+		return field === "_id" ? toObjectId(value) : value;
+	}
+	normalizeList(field, values) {
+		return values.map((value) => this.normalize(field, value));
+	}
+	async write(run) {
+		try {
+			return await run();
+		} catch (error) {
+			throw translateDatabaseError(error);
+		}
+	}
+	writableFilter(action, options) {
+		const filter = this.scopedFilter();
+		if (!Object.keys(filter).length && !options.all) throw new DatabaseError(`Refusing to ${action} all documents of "${this.collectionName}" without conditions. Pass { all: true } to confirm.`);
+		return filter;
+	}
+	async group(accumulator) {
+		const [row] = await this.aggregate([{ $group: {
+			_id: null,
+			value: accumulator
+		} }]);
+		return row?.value;
+	}
+};
+/** Mongo 模型查询：结果为模型实例，应用软删除范围，支持预加载与作用域 */
+var MongoModelQuery = class extends MongoQuery {
+	model;
+	trashed = "without";
+	eager = [];
+	constructor(model) {
+		super(model.collection, { connection: model.connection });
+		this.model = model;
+	}
+	withTrashed() {
+		this.trashed = "with";
+		return this;
+	}
+	onlyTrashed() {
+		this.trashed = "only";
+		return this;
+	}
+	with(...relations) {
+		this.eager.push(...relations);
+		return this;
+	}
+	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;
+	}
+	/** 按 _id 查询（字符串自动转为 ObjectId）；不传时取第一条 */
+	async find(id) {
+		if (id === void 0) return super.find();
+		const [first] = await this.clone().where("_id", id).limit(1).select();
+		return first;
+	}
+	async findOrFail(id) {
+		const model = await this.find(id);
+		if (!model) throw new ModelNotFoundException(this.model.name, id);
+		return model;
+	}
+	/** 批量删除：启用软删除时只标记删除时间 */
+	async delete(options = {}) {
+		const { softDelete } = metaOfMongo(this.model);
+		if (softDelete && this.trashed !== "only") return this.update({ [softDelete]: /* @__PURE__ */ new Date() }, options);
+		return super.delete(options);
+	}
+	async forceDelete(options = {}) {
+		return super.delete(options);
+	}
+	async restore(options = {}) {
+		const { softDelete } = metaOfMongo(this.model);
+		if (!softDelete) return 0;
+		return this.withTrashed().update({ [softDelete]: null }, options);
+	}
+	scopedFilter() {
+		const filter = this.buildFilter();
+		const { softDelete } = metaOfMongo(this.model);
+		if (!softDelete || this.trashed === "with") return filter;
+		const scope = { [softDelete]: this.trashed === "only" ? { $ne: null } : null };
+		return Object.keys(filter).length ? { $and: [filter, scope] } : scope;
+	}
+	async transform(docs) {
+		const models = docs.map((doc) => hydrateMongoModel(this.model, doc));
+		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;
+	}
+};
+// src/mongo/index.ts
+function scoped(connection) {
+	return {
+		collection: (name) => new MongoQuery(name, { connection }),
+		transaction: (callback) => mongoTransaction(callback, connection),
+		db: async () => (await resolveMongo(connection)).db
+	};
+}
+/** MongoDB 门面：默认连接的快捷入口，`Mongo.connection(name)` 切换连接 */
+const Mongo = {
+	...scoped(),
+	connection: (name) => scoped(name)
+};
+export { Mongo, MongoModel, MongoModelQuery, MongoQuery, ObjectId, hydrateMongoModel, metaOfMongo, mongoTransaction, resolveMongo, toObjectId };