@ubean/server 0.1.13 → 0.2.1

package/dist/database-DNrY44SQ.js

@@ -0,0 +1,352 @@
+import { createHooks } from "hookable";
+//#region src/database.ts
+const _global = globalThis;
+const dbRegistry = /* @__PURE__ */ new Map();
+const dbHooks = createHooks();
+let defaultDatabase = null;
+const RAW_SQL = Symbol("rawSql");
+function rawSql(str) {
+	return {
+		[RAW_SQL]: true,
+		value: str
+	};
+}
+function createInMemoryDatabase() {
+	const tables = /* @__PURE__ */ new Map();
+	function getTable(name) {
+		return tables.get(name.toLowerCase());
+	}
+	function parseSqlValue(val) {
+		const trimmed = val.trim();
+		const upper = trimmed.toUpperCase();
+		if (upper === "NULL") return null;
+		if (upper === "TRUE") return true;
+		if (upper === "FALSE") return false;
+		if (/^-?\d+$/.test(trimmed)) return parseInt(trimmed, 10);
+		if (/^-?\d+\.\d+$/.test(trimmed)) return parseFloat(trimmed);
+		if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith("\"") && trimmed.endsWith("\"")) {
+			const quote = trimmed[0];
+			return trimmed.slice(1, -1).replace(new RegExp(quote + quote, "g"), quote);
+		}
+		return trimmed;
+	}
+	function splitByCommaRespectingStrings(str) {
+		const parts = [];
+		let current = "";
+		let inString = false;
+		let stringChar = "";
+		let depth = 0;
+		for (let i = 0; i < str.length; i++) {
+			const ch = str[i];
+			const next = str[i + 1];
+			if (!inString && (ch === "'" || ch === "\"")) {
+				inString = true;
+				stringChar = ch;
+				current += ch;
+			} else if (inString && ch === stringChar) {
+				if (next === stringChar) {
+					current += ch + ch;
+					i++;
+				} else {
+					inString = false;
+					current += ch;
+				}
+			} else if (!inString && ch === "(") {
+				depth++;
+				current += ch;
+			} else if (!inString && ch === ")") {
+				depth--;
+				current += ch;
+			} else if (!inString && depth === 0 && ch === ",") {
+				parts.push(current.trim());
+				current = "";
+			} else current += ch;
+		}
+		if (current.trim()) parts.push(current.trim());
+		return parts;
+	}
+	function parseCreateTable(query) {
+		const ifNotExists = /IF\s+NOT\s+EXISTS/i.test(query);
+		const match = query.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?(\w+)["`]?\s*\(([\s\S]+)\)\s*;?\s*$/i);
+		if (!match) return;
+		const [, tableName, colsStr] = match;
+		const lowerName = tableName.toLowerCase();
+		if (ifNotExists && tables.has(lowerName)) return;
+		const table = {
+			name: tableName,
+			columns: /* @__PURE__ */ new Map(),
+			rows: []
+		};
+		const colDefs = splitByCommaRespectingStrings(colsStr);
+		for (const colDef of colDefs) {
+			const upperDef = colDef.toUpperCase().trim();
+			if (upperDef.startsWith("PRIMARY KEY") || upperDef.startsWith("CONSTRAINT") || upperDef.startsWith("FOREIGN") || upperDef.startsWith("UNIQUE") || upperDef.startsWith("INDEX")) continue;
+			const match2 = colDef.match(/^["`]?(\w+)["`]?\s+(\w+)?(.*)$/);
+			if (!match2) continue;
+			const [, colNameRaw, colTypeRaw = "TEXT", rest] = match2;
+			const colName = colNameRaw.replace(/["`]/g, "");
+			const colType = (colTypeRaw || "TEXT").toUpperCase();
+			const isPK = /PRIMARY\s+KEY/i.test(rest);
+			const notNull = /NOT\s+NULL/i.test(rest);
+			table.columns.set(colName, {
+				type: colType,
+				primaryKey: isPK,
+				notNull
+			});
+		}
+		tables.set(lowerName, table);
+	}
+	function parseInsert(query) {
+		const insertMatch = query.match(/INSERT\s+INTO\s+["`]?(\w+)["`]?\s*(?:\(([^)]+)\))?\s*VALUES\s*\(([\s\S]+)\)\s*;?\s*$/i);
+		if (!insertMatch) return null;
+		const [, tableName, colsStr, valuesStr] = insertMatch;
+		const table = getTable(tableName);
+		if (!table) return null;
+		const columns = colsStr ? splitByCommaRespectingStrings(colsStr).map((c) => c.trim().replace(/["`]/g, "")) : Array.from(table.columns.keys());
+		const values = splitByCommaRespectingStrings(valuesStr).map((s) => parseSqlValue(s));
+		return {
+			table: tableName.toLowerCase(),
+			columns,
+			values
+		};
+	}
+	function parseSelect(query) {
+		const simpleMatch = query.match(/SELECT\s+([\s\S]+?)\s+FROM\s+["`]?(\w+)["`]?/i);
+		if (!simpleMatch) return null;
+		const tableName = simpleMatch[2];
+		let where;
+		const whereIdx = query.toUpperCase().indexOf("WHERE");
+		if (whereIdx !== -1) {
+			let wherePart = query.slice(whereIdx + 5);
+			const orderIdx = wherePart.toUpperCase().indexOf("ORDER");
+			const limitIdx = wherePart.toUpperCase().indexOf("LIMIT");
+			let endIdx = wherePart.length;
+			if (orderIdx !== -1) endIdx = Math.min(endIdx, orderIdx);
+			if (limitIdx !== -1) endIdx = Math.min(endIdx, limitIdx);
+			wherePart = wherePart.slice(0, endIdx).trim().replace(/;$/, "");
+			const eqIdx = wherePart.indexOf("=");
+			if (eqIdx !== -1) where = {
+				col: wherePart.slice(0, eqIdx).trim().replace(/["`]/g, ""),
+				val: parseSqlValue(wherePart.slice(eqIdx + 1).trim())
+			};
+		}
+		return {
+			table: tableName.toLowerCase(),
+			where
+		};
+	}
+	function escapeValue(val) {
+		if (val !== null && typeof val === "object" && RAW_SQL in val) return val.value;
+		if (val === null || val === void 0) return "NULL";
+		if (typeof val === "number") return String(val);
+		if (typeof val === "boolean") return val ? "1" : "0";
+		if (val instanceof Date) return `'${val.toISOString()}'`;
+		return `'${String(val).replace(/'/g, "''")}'`;
+	}
+	function buildQueryFromTemplate(strings, values) {
+		let query = "";
+		for (let i = 0; i < strings.length; i++) {
+			query += strings[i];
+			if (i < values.length) query += escapeValue(values[i]);
+		}
+		return query;
+	}
+	function executeRaw(query) {
+		const upperQuery = query.toUpperCase().trim();
+		if (upperQuery.startsWith("CREATE TABLE")) {
+			parseCreateTable(query);
+			return [];
+		}
+		if (upperQuery.startsWith("INSERT INTO")) {
+			const parsed = parseInsert(query);
+			if (parsed) {
+				const table = getTable(parsed.table);
+				if (table) {
+					const row = {};
+					for (let i = 0; i < parsed.columns.length; i++) row[parsed.columns[i]] = parsed.values[i] ?? null;
+					table.rows.push(row);
+				}
+			}
+			return [];
+		}
+		if (upperQuery.startsWith("SELECT")) {
+			const parsed = parseSelect(query);
+			if (parsed) {
+				const table = getTable(parsed.table);
+				if (!table) return [];
+				let rows = [...table.rows];
+				if (parsed.where) rows = rows.filter((row) => row[parsed.where.col] == parsed.where.val);
+				return rows;
+			}
+			return [];
+		}
+		if (upperQuery.startsWith("DELETE FROM")) {
+			const match = query.match(/DELETE\s+FROM\s+["`]?(\w+)["`]?\s*(?:WHERE\s+(.+))?/i);
+			if (match) {
+				const table = getTable(match[1]);
+				if (table) {
+					const whereStr = match[2];
+					if (whereStr) {
+						const eqIdx = whereStr.indexOf("=");
+						if (eqIdx !== -1) {
+							const col = whereStr.slice(0, eqIdx).trim().replace(/["`]/g, "");
+							const val = parseSqlValue(whereStr.slice(eqIdx + 1).trim());
+							table.rows = table.rows.filter((row) => row[col] != val);
+						} else table.rows = [];
+					} else table.rows = [];
+				}
+			}
+			return [];
+		}
+		if (upperQuery.startsWith("DROP TABLE")) {
+			const match = query.match(/DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?["`]?(\w+)["`]?/i);
+			if (match) tables.delete(match[1].toLowerCase());
+			return [];
+		}
+		return [];
+	}
+	return {
+		async sql(strings, ...values) {
+			const query = buildQueryFromTemplate(strings, values);
+			try {
+				await dbHooks.callHook("db:query", query, values);
+				return { rows: executeRaw(query) };
+			} catch (err) {
+				await dbHooks.callHook("db:error", err instanceof Error ? err : new Error(String(err)), query);
+				throw err;
+			}
+		},
+		async exec(query) {
+			const statements = splitSqlStatements(query);
+			for (const stmt of statements) {
+				const trimmed = stmt.trim();
+				if (!trimmed) continue;
+				try {
+					await dbHooks.callHook("db:query", trimmed);
+					executeRaw(trimmed);
+				} catch (err) {
+					await dbHooks.callHook("db:error", err instanceof Error ? err : new Error(String(err)), trimmed);
+					throw err;
+				}
+			}
+		},
+		async close() {
+			tables.clear();
+		}
+	};
+}
+function splitSqlStatements(sql) {
+	const statements = [];
+	let current = "";
+	let inString = false;
+	let stringChar = "";
+	for (let i = 0; i < sql.length; i++) {
+		const ch = sql[i];
+		if (!inString && (ch === "'" || ch === "\"")) {
+			inString = true;
+			stringChar = ch;
+			current += ch;
+		} else if (inString && ch === stringChar) {
+			if (sql[i + 1] === stringChar) {
+				current += ch + ch;
+				i++;
+			} else {
+				inString = false;
+				current += ch;
+			}
+		} else if (!inString && ch === ";") {
+			statements.push(current);
+			current = "";
+		} else current += ch;
+	}
+	if (current.trim()) statements.push(current);
+	return statements;
+}
+function wrapDatabase(raw, name) {
+	const db = {
+		sql: raw.sql,
+		exec: raw.exec,
+		async close() {
+			await raw.close();
+			if (name) dbRegistry.delete(name);
+			if (defaultDatabase === db) defaultDatabase = null;
+			await dbHooks.callHook("db:disconnect", db);
+		}
+	};
+	return db;
+}
+function defineDatabase(options = {}) {
+	if (!options.connector && !options.connectors) {
+		const db = wrapDatabase(createInMemoryDatabase());
+		if (!defaultDatabase) defaultDatabase = db;
+		dbRegistry.set("default", db);
+		dbHooks.callHook("db:connect", db);
+		return db;
+	}
+	const createFn = _global.$db0Create;
+	let raw;
+	if (options.connector) {
+		if (createFn) try {
+			raw = createFn(options.connector);
+		} catch {
+			raw = createInMemoryDatabase();
+		}
+		else raw = createInMemoryDatabase();
+	} else if (options.connectors) {
+		const defaultName = options.default || Object.keys(options.connectors)[0];
+		const connector = options.connectors[defaultName];
+		if (connector && createFn) try {
+			raw = createFn(connector);
+		} catch {
+			raw = createInMemoryDatabase();
+		}
+		else raw = createInMemoryDatabase();
+	} else raw = createInMemoryDatabase();
+	const dbName = options.default || "default";
+	const db = wrapDatabase(raw, dbName);
+	dbRegistry.set(dbName, db);
+	if (!defaultDatabase) defaultDatabase = db;
+	dbHooks.callHook("db:connect", db);
+	return db;
+}
+function useDatabase(name) {
+	if (name) {
+		const db = dbRegistry.get(name);
+		if (!db) throw new Error(`Database '${name}' not found. Call defineDatabase() first.`);
+		return db;
+	}
+	if (!defaultDatabase) defaultDatabase = defineDatabase();
+	return defaultDatabase;
+}
+async function closeDatabases() {
+	const dbs = Array.from(dbRegistry.values());
+	dbRegistry.clear();
+	defaultDatabase = null;
+	for (const db of dbs) await db.close();
+}
+function getDatabaseHooks() {
+	return dbHooks;
+}
+function registerDb0Create(fn) {
+	_global.$db0Create = fn;
+}
+async function migrateDatabase(db, migrations) {
+	for (const migration of migrations) await db.exec(migration);
+}
+async function runMigrations(db, migrations, options = {}) {
+	const tableName = options.table || "_migrations";
+	const applied = [];
+	await db.exec(`CREATE TABLE IF NOT EXISTS ${tableName} (name TEXT PRIMARY KEY, applied_at INTEGER)`);
+	const { rows } = await db.sql`SELECT name FROM ${rawSql(tableName)}`;
+	const appliedNames = new Set(rows.map((r) => r.name));
+	for (const migration of migrations) {
+		if (appliedNames.has(migration.name)) continue;
+		await db.exec(migration.up);
+		await db.sql`INSERT INTO ${rawSql(tableName)} (name, applied_at) VALUES (${migration.name}, ${Date.now()})`;
+		applied.push(migration.name);
+		if (options.log) console.log(`[db] Applied migration: ${migration.name}`);
+	}
+	return { applied };
+}
+//#endregion
+export { rawSql as a, useDatabase as c, migrateDatabase as i, defineDatabase as n, registerDb0Create as o, getDatabaseHooks as r, runMigrations as s, closeDatabases as t };

package/dist/database.d.ts

@@ -0,0 +1,2 @@
+import { a as DatabaseOptions, c as closeDatabases, d as migrateDatabase, f as rawSql, h as useDatabase, i as DatabaseHooks, l as defineDatabase, m as runMigrations, n as DatabaseConnector, o as DrizzleConfig, p as registerDb0Create, r as DatabaseConnectorInstance, s as Migration, t as Database, u as getDatabaseHooks } from "./database-CfpFznl-.js";
+export { Database, DatabaseConnector, DatabaseConnectorInstance, DatabaseHooks, DatabaseOptions, DrizzleConfig, Migration, closeDatabases, defineDatabase, getDatabaseHooks, migrateDatabase, rawSql as raw, rawSql, rawSql as sqlRaw, registerDb0Create, runMigrations, useDatabase };

package/dist/database.js

@@ -0,0 +1,2 @@
+import { a as rawSql, c as useDatabase, i as migrateDatabase, n as defineDatabase, o as registerDb0Create, r as getDatabaseHooks, s as runMigrations, t as closeDatabases } from "./database-DNrY44SQ.js";
+export { closeDatabases, defineDatabase, getDatabaseHooks, migrateDatabase, rawSql as raw, rawSql, rawSql as sqlRaw, registerDb0Create, runMigrations, useDatabase };

package/dist/email-BjfRiR9b.js

@@ -0,0 +1,354 @@
+import { getLogger } from "@ubean/logger";
+//#region src/email.ts
+/**
+* P9-25 邮件发送原语 —— Email sending primitives
+*
+* 内置邮件发送原语,提供 provider 抽象层。支持三种内置 provider:
+* - `log`   开发环境,将邮件内容输出到 console(或自定义 logger)
+* - `smtp`  生产环境,通过 nodemailer(可选 peer dependency)配置 SMTP/sendmail
+* - `mock`  测试环境,捕获发送的邮件以便断言
+*
+* 设计对齐 `storage.ts` 的 driver 抽象与 `queue.ts` 的全局 driver 注册模式:
+* - `defineEmailProvider(options)` 定义并注册一个 provider
+* - `createEmailTransport(provider)` 从 provider 配置创建 transport
+* - `sendEmail(options)` 使用全局默认 transport 发送邮件
+* - `renderEmailTemplate(template, data)` 简单字符串插值渲染
+*
+* 用法:
+* ```typescript
+* import { defineEmailProvider, sendEmail, renderEmailTemplate } from '@ubean/server';
+*
+* // 定义默认 provider(开发环境用 log)
+* defineEmailProvider({ type: 'log', default: true });
+*
+* // 发送邮件
+* await sendEmail({
+*   to: 'user@example.com',
+*   from: 'noreply@example.com',
+*   subject: 'Welcome',
+*   html: renderEmailTemplate('<h1>Hello {{name}}</h1>', { name: 'Alice' }),
+*   text: 'Hello Alice'
+* });
+* ```
+*/
+function generateMessageId(prefix) {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return `${prefix}-${crypto.randomUUID()}`;
+	return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+function joinRecipients(to) {
+	return Array.isArray(to) ? to.join(", ") : to;
+}
+/**
+* 从对象中按点号路径读取嵌套值
+*/
+function getNestedValue(obj, path) {
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current === null || current === void 0) return void 0;
+		current = current[part];
+	}
+	return current;
+}
+function createLogTransport(config) {
+	const logger = config.logger || ((msg) => getLogger("email").info(msg));
+	return {
+		async send(options) {
+			const lines = [
+				`[ubean-email] ${options.subject}`,
+				`  From: ${options.from}`,
+				`  To: ${joinRecipients(options.to)}`
+			];
+			if (options.cc) lines.push(`  Cc: ${joinRecipients(options.cc)}`);
+			if (options.bcc) lines.push(`  Bcc: ${joinRecipients(options.bcc)}`);
+			if (options.replyTo) lines.push(`  Reply-To: ${options.replyTo}`);
+			if (options.text) lines.push(`  Text: ${options.text}`);
+			if (options.html) {
+				const preview = options.html.length > 100 ? `${options.html.slice(0, 100)}...` : options.html;
+				lines.push(`  HTML: ${preview}`);
+			}
+			if (options.attachments && options.attachments.length > 0) lines.push(`  Attachments: ${options.attachments.map((a) => a.filename).join(", ")}`);
+			logger(lines.join("\n"));
+			return {
+				messageId: generateMessageId("log"),
+				provider: "log"
+			};
+		},
+		async verify() {
+			return true;
+		}
+	};
+}
+function createMockTransport(_config) {
+	const sent = [];
+	return {
+		sent,
+		clear() {
+			sent.length = 0;
+		},
+		async send(options) {
+			sent.push(options);
+			return {
+				messageId: generateMessageId("mock"),
+				provider: "mock"
+			};
+		},
+		async verify() {
+			return true;
+		}
+	};
+}
+function createSmtpTransport(config) {
+	let nodemailerTransport = null;
+	async function getNodemailerTransport() {
+		if (nodemailerTransport) return nodemailerTransport;
+		let nodemailer;
+		try {
+			nodemailer = await import("nodemailer");
+		} catch {
+			throw new Error("[ubean] nodemailer is not installed. Install it with: pnpm add nodemailer");
+		}
+		nodemailerTransport = nodemailer.createTransport({
+			host: config.host,
+			port: config.port,
+			secure: config.secure,
+			auth: config.auth,
+			...config.extra
+		});
+		return nodemailerTransport;
+	}
+	return {
+		async send(options) {
+			const result = await (await getNodemailerTransport()).sendMail({
+				from: options.from,
+				to: joinRecipients(options.to),
+				cc: options.cc ? joinRecipients(options.cc) : void 0,
+				bcc: options.bcc ? joinRecipients(options.bcc) : void 0,
+				replyTo: options.replyTo,
+				subject: options.subject,
+				text: options.text,
+				html: options.html,
+				headers: options.headers,
+				attachments: options.attachments?.map((a) => ({
+					filename: a.filename,
+					content: a.content,
+					contentType: a.contentType,
+					encoding: a.encoding,
+					cid: a.cid
+				}))
+			});
+			return {
+				messageId: result.messageId,
+				response: result.response,
+				provider: "smtp"
+			};
+		},
+		async verify() {
+			return (await getNodemailerTransport()).verify();
+		},
+		async close() {
+			if (nodemailerTransport) {
+				nodemailerTransport.close();
+				nodemailerTransport = null;
+			}
+		}
+	};
+}
+function createSendmailTransport(config) {
+	let nodemailerTransport = null;
+	async function getNodemailerTransport() {
+		if (nodemailerTransport) return nodemailerTransport;
+		let nodemailer;
+		try {
+			nodemailer = await import("nodemailer");
+		} catch {
+			throw new Error("[ubean] nodemailer is not installed. Install it with: pnpm add nodemailer");
+		}
+		nodemailerTransport = nodemailer.createTransport({
+			sendmail: true,
+			path: config.path || "/usr/sbin/sendmail",
+			args: config.args || ["-i"]
+		});
+		return nodemailerTransport;
+	}
+	return {
+		async send(options) {
+			const result = await (await getNodemailerTransport()).sendMail({
+				from: options.from,
+				to: joinRecipients(options.to),
+				cc: options.cc ? joinRecipients(options.cc) : void 0,
+				bcc: options.bcc ? joinRecipients(options.bcc) : void 0,
+				replyTo: options.replyTo,
+				subject: options.subject,
+				text: options.text,
+				html: options.html,
+				headers: options.headers,
+				attachments: options.attachments?.map((a) => ({
+					filename: a.filename,
+					content: a.content,
+					contentType: a.contentType,
+					encoding: a.encoding,
+					cid: a.cid
+				}))
+			});
+			return {
+				messageId: result.messageId,
+				response: result.response,
+				provider: "sendmail"
+			};
+		},
+		async close() {
+			if (nodemailerTransport) {
+				nodemailerTransport.close();
+				nodemailerTransport = null;
+			}
+		}
+	};
+}
+const providerRegistry = /* @__PURE__ */ new Map();
+let globalProvider = null;
+let globalTransport = null;
+/**
+* 定义并注册一个邮件 provider
+*
+* @example
+* ```typescript
+* // 开发环境
+* defineEmailProvider({ type: 'log', default: true });
+*
+* // 生产环境
+* defineEmailProvider({
+*   type: 'smtp',
+*   name: 'primary',
+*   default: true,
+*   host: 'smtp.example.com',
+*   port: 587,
+*   auth: { user: 'postmaster', pass: 'secret' }
+* });
+* ```
+*/
+function defineEmailProvider(options) {
+	const { name, default: isDefault, ...config } = options;
+	const provider = {
+		type: config.type,
+		name,
+		config
+	};
+	if (name) providerRegistry.set(name, provider);
+	if (isDefault) setDefaultEmailProvider(provider);
+	return provider;
+}
+/**
+* 从 provider 配置创建 transport
+*/
+function createEmailTransport(provider) {
+	switch (provider.config.type) {
+		case "log": return createLogTransport(provider.config);
+		case "mock": return createMockTransport(provider.config);
+		case "smtp": return createSmtpTransport(provider.config);
+		case "sendmail": return createSendmailTransport(provider.config);
+		default: {
+			const exhaustive = provider.config;
+			throw new Error(`[ubean] Unknown email provider type: ${exhaustive.type}`);
+		}
+	}
+}
+/**
+* 设置全局默认 provider(并立即创建其 transport)
+*/
+function setDefaultEmailProvider(provider) {
+	globalProvider = provider;
+	globalTransport = createEmailTransport(provider);
+}
+/**
+* 获取全局默认 provider。若尚未设置,则惰性创建一个 `log` provider。
+*/
+function useEmailProvider() {
+	if (!globalProvider) {
+		globalProvider = defineEmailProvider({ type: "log" });
+		globalTransport = createEmailTransport(globalProvider);
+	}
+	return globalProvider;
+}
+/**
+* 获取全局默认 transport。若尚未设置,则惰性创建一个 `log` transport。
+*/
+function getEmailTransport() {
+	if (!globalTransport) useEmailProvider();
+	return globalTransport;
+}
+/**
+* 按名称获取已注册的 provider
+*/
+function getEmailProvider(name) {
+	return providerRegistry.get(name);
+}
+/**
+* 获取所有已注册的 provider 名称
+*/
+function getEmailProviderNames() {
+	return Array.from(providerRegistry.keys());
+}
+/**
+* 使用全局默认 transport 发送邮件
+*
+* @example
+* ```typescript
+* await sendEmail({
+*   to: 'user@example.com',
+*   from: 'noreply@example.com',
+*   subject: 'Welcome',
+*   html: '<h1>Welcome!</h1>',
+*   text: 'Welcome!'
+* });
+* ```
+*/
+async function sendEmail(options) {
+	if (!options.to) throw new Error("[ubean] sendEmail: \"to\" is required");
+	if (!options.from) throw new Error("[ubean] sendEmail: \"from\" is required");
+	if (!options.subject) throw new Error("[ubean] sendEmail: \"subject\" is required");
+	return getEmailTransport().send(options);
+}
+/**
+* 简单模板渲染 —— `{{key}}` 字符串插值,支持点号嵌套路径
+*
+* @example
+* ```typescript
+* renderEmailTemplate('Hello {{user.name}}, your code is {{code}}', {
+*   user: { name: 'Alice' },
+*   code: '123456'
+* });
+* // => 'Hello Alice, your code is 123456'
+* ```
+*/
+function renderEmailTemplate(template, data) {
+	return template.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_match, key) => {
+		const value = getNestedValue(data, key.trim());
+		return value !== void 0 && value !== null ? String(value) : "";
+	});
+}
+/**
+* 获取全局 mock transport 捕获的已发送邮件。
+* 若全局 transport 不是 mock,则返回空数组。
+*/
+function getSentEmails() {
+	if (globalTransport && "sent" in globalTransport) return globalTransport.sent;
+	return [];
+}
+/**
+* 清空全局 mock transport 捕获的已发送邮件。
+* 若全局 transport 不是 mock,则不做任何操作。
+*/
+function clearSentEmails() {
+	if (globalTransport && "sent" in globalTransport) globalTransport.clear();
+}
+/**
+* 清除所有 provider 注册表与全局状态(主要用于测试隔离)
+*/
+function clearEmailProviders() {
+	providerRegistry.clear();
+	globalProvider = null;
+	globalTransport = null;
+}
+//#endregion
+export { getEmailProvider as a, getSentEmails as c, setDefaultEmailProvider as d, useEmailProvider as f, defineEmailProvider as i, renderEmailTemplate as l, clearSentEmails as n, getEmailProviderNames as o, createEmailTransport as r, getEmailTransport as s, clearEmailProviders as t, sendEmail as u };