@yongdall/core 0.4.5 → 0.5.2

package/index.mjs

@@ -1,22 +1,25 @@
-import { Hook, Search, isFunction } from "@yongdall/common";
+import { Hook, LazyPromise, Search, isFunction } from "@yongdall/common";
 import { Query, Where, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, coefficient, decrement, expandModel, getDefinePermission, increment, multiply } from "@yongdall/model";
 import { createKeyStore, createStoreSerializable } from "@yongdall/context";
+import { loadPluginProfiles } from "@yongdall/plugins";
 
 //#region packages/core/polyfill.mjs
 if (!Symbol.metadata) Symbol.metadata = Symbol.for("Symbol.metadata");
 
 //#endregion
 //#region packages/core/config.mjs
-/** @import { Tenant } from '@yongdall/types' */
+/** @import { Realm } from '@yongdall/types' */
 /** @import { BootConfiguration } from '@yongdall/common' */
-/** @type {Tenant} */
-const mainTenant = {
+/** @type {Realm} */
+const mainRealm = {
 	id: "",
 	label: "拥道YongDall",
 	single: false,
 	providers: {},
 	salt: "YongDall"
 };
+/** @deprecated */
+const mainTenant = mainRealm;
 /** @type {BootConfiguration} */
 const bootConfiguration = {
 	pages: {},
@@ -26,16 +29,16 @@ const bootConfiguration = {
 };
 /**
 * 
-* @param {Partial<Omit<Tenant, 'id'>>} tenant 
+* @param {Partial<Omit<Realm, 'id'>>} realm 
 * @param {object} boot 
 * @returns 
 */
 function initConfig({ label, single, providers, salt }, boot) {
 	Object.assign(bootConfiguration, boot);
-	mainTenant.label = typeof label === "string" && label || "拥道YongDall";
-	mainTenant.single = Boolean(single);
-	if (salt) mainTenant.salt = salt;
-	mainTenant.providers = Object.fromEntries(Object.entries(typeof providers === "object" && providers || {}).filter(([k, v]) => typeof v === "string" && v));
+	mainRealm.label = typeof label === "string" && label || "拥道YongDall";
+	mainRealm.single = Boolean(single);
+	if (salt) mainRealm.salt = salt;
+	mainRealm.providers = Object.fromEntries(Object.entries(typeof providers === "object" && providers || {}).filter(([k, v]) => typeof v === "string" && v));
 }
 
 //#endregion
@@ -60,23 +63,21 @@ function getMenus(type, group = "") {
 //#region packages/core/models.mjs
 /** @import { Permission } from '@yongdall/types' */
 /** @import { FieldDefine, Fields, ModelTable, TableDefine } from '@yongdall/model' */
-/** @import { Hooks } from './types.mjs' */
-/** @type {Hooks['models']} */
-let models = Object.create(null);
-/** @type {Hooks['modelLoaders']} */
-let modelLoaders = Object.create(null);
-/** @type {((modelId: string, groupId?: string | null) => PromiseLike<Permission[] | null> | Permission[] | null)[]} */
-let getModelPermissionsHooks = [];
-/** @type {WeakMap<ModelTable, ModelTable>} */
-let modelMap = /* @__PURE__ */ new WeakMap();
-/** @type {Record<string, Fields<TableDefine>>} */
-let modelExpands = {};
-hooks.listen(() => {
-	modelMap = /* @__PURE__ */ new WeakMap();
-	models = hooks.get("models").named();
-	modelLoaders = hooks.get("modelLoaders").named();
-	getModelPermissionsHooks = [...hooks.get("getModelPermissions").values()].filter((v) => typeof v === "function");
-	const modelFields = [...hooks.get("modelExpands").entriesObject()].flatMap(([p, modelId, fields]) => [fields].flatMap((v) => {
+/** @import { ModelProfile } from './types.mjs' */
+const ModelProfilePromise = LazyPromise.try(async function() {
+	return await Array.fromAsync(loadPluginProfiles("model", (v) => [v]));
+});
+const modelsPromise = ModelProfilePromise.lazyThen((list) => {
+	return Object.fromEntries(list.flatMap((v) => Object.entries(v.models || {})));
+});
+const modelLoadersPromise = ModelProfilePromise.lazyThen((list) => {
+	return Object.fromEntries(list.flatMap((v) => Object.entries(v.modelLoaders || {})));
+});
+const getModelPermissionsHooksPromise = ModelProfilePromise.lazyThen((list) => {
+	return list.map((v) => v.getModelPermissions).filter((v) => typeof v === "function");
+});
+const modelExpandsPromise = ModelProfilePromise.lazyThen((list) => {
+	const modelFields = list.flatMap((v) => Object.entries(v.modelExpands || {})).flatMap(([modelId, fields]) => [fields].flatMap((v) => {
 		if (!v || typeof v !== "object" || Array.isArray(v)) return [];
 		return Object.entries(v).map(([fieldName, field]) => [
 			modelId,
@@ -91,8 +92,9 @@ hooks.listen(() => {
 		if (!fields?.length) continue;
 		expands[modelId] = Object.fromEntries(fields.map(([, fieldName, field]) => [fieldName, field]));
 	}
-	modelExpands = expands;
-}, -1e6);
+	return expands;
+});
+const modelMap = /* @__PURE__ */ new WeakMap();
 /**
 * 
 * @param {string | string[]} ident 
@@ -101,9 +103,11 @@ hooks.listen(() => {
 async function findModel(ident) {
 	const [model, ...collection] = (Array.isArray(ident) ? ident : ident.split(":")).filter(Boolean);
 	if (!collection.length) {
+		const models = await modelsPromise;
 		const define = Object.hasOwn(models, model) && models[model];
 		return (typeof define === "object" || typeof define === "function") && define || null;
 	}
+	const modelLoaders = await modelLoadersPromise;
 	const loader = Object.hasOwn(modelLoaders, model) && modelLoaders[model];
 	if (typeof loader !== "function") return null;
 	const define = await loader(collection);
@@ -120,13 +124,14 @@ async function getModel(ident) {
 	const define = modelMap.get(model);
 	if (define) return define;
 	const modelIdent = Array.isArray(ident) ? ident.join(":") : ident;
+	const modelExpands = await modelExpandsPromise;
 	const newDefine = expandModel(model, Object.hasOwn(modelExpands, modelIdent) ? modelExpands[modelIdent] : {});
 	modelMap.set(model, newDefine);
 	return newDefine;
 }
 /** @type {(modelId: string, groupId?: string?) => Promise<Permission[]?>} */
 const getModelPermissions = createKeyStore(async (modelId, groupId) => {
-	for (const fn of getModelPermissionsHooks) {
+	for (const fn of await getModelPermissionsHooksPromise) {
 		const permissions = await fn(modelId, groupId);
 		if (permissions) return permissions;
 	}
@@ -152,56 +157,129 @@ async function getModelAuthorizationPermissions(modelId, authorization, groupId)
 }
 
 //#endregion
-//#region packages/core/tenant.mjs
-/** @import { Tenant } from '@yongdall/types' */
-const [tenantGetter, tenantSetter] = createStoreSerializable("tenantStatus", async (state) => {
+//#region packages/core/realm.mjs
+/** @import { Realm } from '@yongdall/types' */
+/** @import { RealmHook } from './types.mjs' */
+const [realmIdGetter, realmIdSetter] = createStoreSerializable("realmStatus", async (realmId) => {
+	return { realm: await realmId || null };
+}, (val) => {
+	return Promise.resolve(val?.realm || null);
+}, null);
+const hooks$1 = LazyPromise.try(async function() {
+	return (await Array.fromAsync(loadPluginProfiles("realm"))).map((v) => v[1]);
+});
+/**
+* 
+* @param {string} realmId 
+* @returns {Promise<boolean>}
+*/
+async function existRealm(realmId) {
+	for (const { exist, load } of await hooks$1) if (typeof exist === "function") {
+		if (await exist(realmId)) return true;
+	} else if (typeof load === "function") {
+		if (await load(realmId)) return true;
+	}
+	return false;
+}
+const getters = hooks$1.lazyThen((hooks) => hooks.map((v) => v.get).filter((v) => typeof v === "function"));
+/**
+* 
+* @returns {Promise<string?>}
+*/
+async function getCurrentRealm() {
+	for (const get of await getters) {
+		const realm = await get();
+		if (!realm || !await existRealm(realm)) continue;
+		return realm;
+	}
+	return null;
+}
+/**
+* 
+* @returns {Promise<string?>}
+*/
+async function useRealmId() {
+	let state = realmIdGetter();
+	if (!state) {
+		state = getCurrentRealm();
+		realmIdSetter(state);
+	}
+	return state;
+}
+const loaders$1 = hooks$1.lazyThen((hooks) => hooks.map((v) => v.load).filter((v) => typeof v === "function"));
+/**
+* 
+* @param {string} realmId 
+* @returns {Promise<Realm?>}
+*/
+async function loadRealm(realmId) {
+	for (const load of await loaders$1) {
+		const realm = await load(realmId);
+		if (realm) return realm;
+	}
+	return null;
+}
+/** @deprecated */
+const [oldRealmGetter, oldRealmSetter] = createStoreSerializable("oldRealmStatus", async (state) => {
 	if (!state) return null;
 	return state;
-}, (tenant) => {
-	return tenant ? Promise.resolve(tenant) : null;
+}, (realm) => {
+	return realm ? Promise.resolve(realm) : null;
 }, null);
-function getTenantManager() {
+/** @deprecated */
+function getRealmManager() {
 	return [...hooks.get("tenantManager").values()].filter(Boolean);
 }
-let tenantManagers = getTenantManager();
+/** @deprecated */
+let realmManagers = getRealmManager();
 hooks.listen(() => {
-	tenantManagers = getTenantManager();
+	realmManagers = getRealmManager();
 }, -1e6);
 /**
-* 
-* @returns {Promise<Tenant>}
+* @deprecated
+* @returns {Promise<Realm>}
 */
-async function getCurrentTenant() {
-	if (!tenantManagers.length) return mainTenant;
-	for (const get of tenantManagers) {
+async function getCurrentOldRealm() {
+	if (!realmManagers.length) return mainRealm;
+	for (const get of realmManagers) {
 		const u = await get();
 		if (!u) continue;
 		return u;
 	}
-	throw new Error("[noTenant] 找不到租户");
+	throw new Error("[noRealm] 找不到域");
 }
-async function get$1() {
-	let state = tenantGetter();
+/** @deprecated */
+async function getOldRealm() {
+	let state = oldRealmGetter();
 	if (!state) {
-		state = getCurrentTenant();
-		tenantSetter(state);
+		state = getCurrentOldRealm();
+		oldRealmSetter(state);
 	}
 	return state;
 }
 /**
 * 
-* @returns {Promise<Tenant>}
+* @returns {Promise<Realm>}
 */
+async function useRealm() {
+	return useRealmId().then(async (id) => {
+		return id && await loadRealm(id) || await getOldRealm();
+	});
+}
+function useSalt() {
+	return useRealm().then((r) => r.salt);
+}
+/** @deprecated */
 function useTenant() {
-	return get$1();
+	return useRealm();
 }
 
 //#endregion
 //#region packages/core/user.mjs
-/** @import { Permissions, Tenant } from '@yongdall/types' */
+/** @import { Permissions, Realm } from '@yongdall/types' */
 /** @import { UserManager, MaybePromise } from './types.mjs' */
 /**
-* @typedef {[result: string | null, UserManager['set'] | null, UserManager['exit'] | null, user: string | null, sUser: string  | null]} State
+* @typedef {[result: string | null, UserManager['set'] | null, UserManager['exit'] | null, user: string | null, sUser: string  | null]} UserState
 */
 const [userGetter, userSetter] = createStoreSerializable("userStatus", async (state) => {
 	if (!state) return null;
@@ -221,80 +299,70 @@ const [userGetter, userSetter] = createStoreSerializable("userStatus", async (st
 		sUserId
 	]);
 }, null);
-function getUserLoaders() {
-	return [...hooks.get("userManager").entries()].map(([k, v]) => [k, v?.loadPlugin]).filter(([, v]) => typeof v === "function");
-}
-function getUserManagers() {
-	/** @type {Partial<UserManager>[]} */
-	const userMangers = [...hooks.get("userManager").values()].filter(Boolean);
-	const defaultLogin = userMangers.find((v) => typeof v.login === "function")?.login || null;
+const userManagerMap = LazyPromise.try(async function() {
+	return await Array.fromAsync(loadPluginProfiles("user"));
+});
+const userManagers = userManagerMap.lazyThen((list) => list.map((v) => v[1]));
+const defaultLogin$1 = userManagers.lazyThen((userMangers) => {
+	return userMangers.find((v) => typeof v.login === "function")?.login || null;
+});
+const switchableListPromise = userManagers.lazyThen((userMangers) => {
 	const switchableList = userMangers.map((v) => v.switchable).filter(isFunction);
-	/** @type {(() => MaybePromise<string?>)[]} */
-	const suGets = userMangers.map((v) => v.suGet).filter(isFunction);
-	/** @type {[UserManager['get'], UserManager['set'] | null, UserManager['exit'] | null][]} */
-	const getLoggedUserFn = [];
-	/** @type {Record<string, ((userId: string, password: string) => MaybePromise<number>)[]>} */
-	const verifiers = Object.create(null);
-	/** @type {Record<string, ((userId: string, password: string?, deadline?: Date?) => MaybePromise<boolean>)[]>} */
-	const setVerifiers = Object.create(null);
-	const finders = userMangers.map((v) => v.find).filter((v) => typeof v === "function");
-	const loaders = userMangers.map((v) => v.load).filter((v) => typeof v === "function");
-	const existTesters = userMangers.map((v) => v.exist).filter((v) => typeof v === "function");
-	const getPermissions = userMangers.map((v) => v.getPermissions).filter((v) => typeof v === "function");
-	const getOrganizationPermissions = userMangers.map((v) => v.getOrganizationPermissions).filter((v) => typeof v === "function");
-	const getOrganizationAllPermissions = userMangers.map((v) => v.getOrganizationAllPermissions).filter((v) => typeof v === "function");
-	for (const { get, set, exit, find, verify, setVerify } of userMangers) {
-		if (typeof get === "function") getLoggedUserFn.push([
-			get,
-			set || null,
-			exit || null
-		]);
-		if (verify) for (const [k, v] of Object.entries(verify)) {
-			const list = verifiers[k];
-			if (list) list.push(v);
-			else verifiers[k] = [v];
-		}
-		if (setVerify) for (const [k, v] of Object.entries(setVerify)) {
-			const list = setVerifiers[k];
-			if (list) list.push(v);
-			else setVerifiers[k] = [v];
-		}
-	}
 	/**
-	* @param {Tenant} tenant 
+	* @param {Realm} realm 
 	* @param {string} user 
 	* @param {string} sUser 
 	* @returns {Promise<boolean>}
 	*/
-	async function switchable(tenant, user, sUser) {
+	return async function switchable(realm, user, sUser) {
 		if (!switchableList.length) return false;
 		for (const s of switchableList) {
 			if (await s(user, sUser)) continue;
 			return false;
 		}
 		return true;
-	}
-	return {
-		defaultLogin,
-		switchable,
-		suGets,
-		getLoggedUserFn,
-		finders,
-		verifiers,
-		setVerifiers,
-		loaders,
-		existTesters,
-		getPermissions,
-		getOrganizationPermissions,
-		getOrganizationAllPermissions
 	};
-}
-let userPluginLoaders = getUserLoaders();
-let { defaultLogin, switchable, suGets, getLoggedUserFn, finders, verifiers, setVerifiers, loaders, existTesters, getPermissions, getOrganizationPermissions, getOrganizationAllPermissions } = getUserManagers();
-hooks.listen(() => {
-	userPluginLoaders = getUserLoaders();
-	({defaultLogin, switchable, suGets, getLoggedUserFn, finders, verifiers, setVerifiers, loaders, existTesters, getPermissions, getOrganizationPermissions, getOrganizationAllPermissions} = getUserManagers());
-}, -1e6);
+});
+const suGets = userManagers.lazyThen((userMangers) => {
+	/** @type {(() => MaybePromise<string?>)[]} */
+	return userMangers.map((v) => v.suGet).filter(isFunction);
+});
+const finders$1 = userManagers.lazyThen((userMangers) => {
+	return userMangers.map((v) => v.find).filter((v) => typeof v === "function");
+});
+const loaders = userManagers.lazyThen((userMangers) => {
+	return userMangers.map((v) => v.load).filter((v) => typeof v === "function");
+});
+const existTesters$1 = userManagers.lazyThen((userMangers) => {
+	return userMangers.map((v) => v.exist).filter((v) => typeof v === "function");
+});
+const getPermissions = userManagers.lazyThen((userMangers) => {
+	return userMangers.map((v) => v.getPermissions).filter((v) => typeof v === "function");
+});
+const getOrganizationPermissions = userManagers.lazyThen((userMangers) => {
+	return userMangers.map((v) => v.getOrganizationPermissions).filter((v) => typeof v === "function");
+});
+const getOrganizationAllPermissions = userManagers.lazyThen((userMangers) => {
+	return userMangers.map((v) => v.getOrganizationAllPermissions).filter((v) => typeof v === "function");
+});
+const getLoggedUserFn = userManagers.lazyThen((userMangers) => {
+	/** @type {[UserManager['get'], UserManager['set'] | null, UserManager['exit'] | null][]} */
+	const getLoggedUserFn = [];
+	for (const { get, set, exit } of userMangers) if (typeof get === "function") getLoggedUserFn.push([
+		get,
+		set || null,
+		exit || null
+	]);
+	return getLoggedUserFn;
+});
+const verifiersPromise = userManagers.lazyThen((userMangers) => {
+	const list = userMangers.map((v) => v).flatMap((v) => Object.entries(v.verify || {}));
+	return Object.fromEntries(Object.entries(Object.groupBy(list, (v) => v[0])).map(([k, v]) => [k, v?.map((v) => v[1]) || []]));
+});
+const setVerifiersPromise = userManagers.lazyThen((userMangers) => {
+	const list = userMangers.map((v) => v).flatMap((v) => Object.entries(v.setVerify || {}));
+	return Object.fromEntries(Object.entries(Object.groupBy(list, (v) => v[0])).map(([k, v]) => [k, v?.map((v) => v[1]) || []]));
+});
 /**
 * 
 * @param {string} userId 
@@ -302,17 +370,17 @@ hooks.listen(() => {
 * @returns {Promise<boolean>}
 */
 async function existUser(userId, login) {
-	for (const fn of existTesters) if (await fn(userId, login)) return true;
+	for (const fn of await existTesters$1) if (await fn(userId, login)) return true;
 	return false;
 }
 /**
 * 
-* @returns {Promise<State>}
+* @returns {Promise<UserState>}
 */
 async function getLoggedUser() {
-	const tenant = await useTenant();
-	if (tenant.single) {
-		for (const suGet of suGets) {
+	const realm = await useRealm();
+	if (realm.single) {
+		for (const suGet of await suGets) {
 			const suUser = await suGet();
 			if (!suUser) continue;
 			if (!await existUser(suUser)) continue;
@@ -338,7 +406,7 @@ async function getLoggedUser() {
 	let exitUser = null;
 	/** @type {string?} */
 	let user = null;
-	for (const [get, set, exit] of getLoggedUserFn) {
+	for (const [get, set, exit] of await getLoggedUserFn) {
 		const u = await get();
 		if (!u || !await existUser(u)) continue;
 		user = u;
@@ -348,16 +416,16 @@ async function getLoggedUser() {
 	}
 	if (!user) return [
 		null,
-		defaultLogin,
+		await defaultLogin$1,
 		null,
 		null,
 		null
 	];
-	for (const suGet of suGets) {
+	for (const suGet of await suGets) {
 		const suUser = await suGet();
 		if (!suUser) continue;
 		if (!await existUser(suUser)) continue;
-		if (await switchable(tenant, user, suUser)) continue;
+		if (await (await switchableListPromise)(realm, user, suUser)) continue;
 		return [
 			null,
 			setUser,
@@ -374,7 +442,7 @@ async function getLoggedUser() {
 		null
 	];
 }
-async function get() {
+async function get$1() {
 	let state = userGetter();
 	if (!state) {
 		state = getLoggedUser();
@@ -387,8 +455,8 @@ async function get() {
 * @returns {Promise<boolean>}
 */
 function isSingleUser(logged) {
-	if (logged) return useTenant().then((g) => g.single);
-	return get().then(([, , , su]) => su ? false : useTenant().then((g) => g.single));
+	if (logged) return useRealm().then((g) => g.single);
+	return get$1().then(([, , , su]) => su ? false : useRealm().then((g) => g.single));
 }
 /**
 * 
@@ -396,7 +464,7 @@ function isSingleUser(logged) {
 * @returns {Promise<string?>}
 */
 function getUser(logged) {
-	return get().then(([, , , current, su]) => {
+	return get$1().then(([, , , current, su]) => {
 		if (logged === false) return su;
 		if (logged) return current;
 		return su || current;
@@ -418,7 +486,7 @@ function setUser(userId, sudo) {
 			current,
 			null
 		];
-		if (current || await useTenant().then((t) => t.single)) return [
+		if (current || await useRealm().then((t) => t.single)) return [
 			userId,
 			set,
 			exit,
@@ -451,7 +519,7 @@ function setUser(userId, sudo) {
 			current,
 			su
 		];
-		if ((await useTenant()).single) return [
+		if ((await useRealm()).single) return [
 			null,
 			set,
 			exit,
@@ -484,7 +552,7 @@ function setUser(userId, sudo) {
 */
 async function findUser(loginName, loginType) {
 	const types = new Set([loginType || ""].flat().filter(Boolean));
-	for (const fn of finders) {
+	for (const fn of await finders$1) {
 		const userId = await fn(loginName, types);
 		if (userId) return userId;
 	}
@@ -499,6 +567,8 @@ async function findUser(loginName, loginType) {
 * @returns {Promise<number>}
 */
 async function verifyUser(userId, password, type, returnError) {
+	const verifiers = await verifiersPromise;
+	if (!Object.hasOwn(verifiers, type)) return 0;
 	for (const fn of verifiers[type] || []) {
 		const res = await fn(userId, password);
 		if (res < 0) return returnError ? res : 0;
@@ -515,13 +585,15 @@ async function verifyUser(userId, password, type, returnError) {
 * @returns {Promise<boolean>}
 */
 async function setUserVerify(userId, type, password, deadline) {
+	const setVerifiers = await setVerifiersPromise;
+	if (!Object.hasOwn(setVerifiers, type)) return false;
 	for (const fn of setVerifiers[type] || []) if (await fn(userId, password, deadline)) return true;
 	return false;
 }
 /** @type {(user?: string?) => Promise<Set<string>>} */
 const loadUserPermissions = createKeyStore(async (user) => {
 	if (!user) return /* @__PURE__ */ new Set();
-	for (const f of getPermissions) {
+	for (const f of await getPermissions) {
 		const r = await f(user);
 		if (r) return new Set(r);
 	}
@@ -553,7 +625,7 @@ async function hasUserPermission(permission, logged) {
 /** @type {(user?: string?) => Promise<Set<string>>} */
 const loadUserOrganizationAllPermissions = createKeyStore(async (user) => {
 	if (!user) return /* @__PURE__ */ new Set();
-	for (const f of getOrganizationAllPermissions) {
+	for (const f of await getOrganizationAllPermissions) {
 		const r = await f(user);
 		if (r) return new Set(r);
 	}
@@ -576,7 +648,7 @@ async function getUserOrganizationAllPermissions(logged) {
 /** @type {(user?: string?) => Promise<Record<string, Set<string>>>} */
 const loadUserOrganizationPermissions = createKeyStore(async (user) => {
 	if (!user) return Object.create(null);
-	for (const f of getOrganizationPermissions) {
+	for (const f of await getOrganizationPermissions) {
 		const r = await f(user);
 		if (r) return Object.assign(Object.create(null), Object.fromEntries(Object.entries(r).map(([k, v]) => [k, new Set(v)])));
 	}
@@ -631,13 +703,17 @@ async function hasUserOrganizationPermissions(permission, organization, logged)
 	if (!permission) return true;
 	return permissions.has(permission);
 }
+const userPluginLoaders = userManagerMap.lazyThen((list) => {
+	return list.map(([k, v]) => [k, v?.loadPlugin]).filter(([, v]) => typeof v === "function");
+});
 /**
 * 
 * @param {string} userId 
 * @returns {Promise<Record<string, any>>}
 */
 async function loadPluginUser(userId) {
-	const list2 = await Promise.all(userPluginLoaders.map(([p, f]) => Promise.all([p, f(userId)])));
+	const loaders = await userPluginLoaders;
+	const list2 = await Promise.all(loaders.map(([p, f]) => Promise.all([p, f(userId)])));
 	return Object.fromEntries(Object.entries(Object.groupBy(list2, ([k]) => k)).map(([k, l]) => {
 		return [k, Object.assign({}, ...l?.map((v) => v[1]) || [])];
 	}));
@@ -649,7 +725,7 @@ async function loadPluginUser(userId) {
 */
 async function loadUser(userId, plugin = false) {
 	const [list, plugins, permissions, organizationPermissions] = await Promise.all([
-		Promise.all(loaders.map((f) => f(userId))),
+		loaders.then((loaders) => Promise.all(loaders.map((f) => f(userId)))),
 		plugin ? loadPluginUser(userId) : {},
 		loadUserPermissions(userId).then((p) => [...p]),
 		loadUserOrganizationPermissions(userId).then((p) => Object.fromEntries(Object.entries(p).map(([k, v]) => [k, [...v]])))
@@ -662,6 +738,160 @@ async function loadUser(userId, plugin = false) {
 	});
 }
 
+//#endregion
+//#region packages/core/visitor.mjs
+/** @import { VisitorManager } from './types.mjs' */
+/**
+* @typedef {[result: string | null, VisitorManager['set'] | null, VisitorManager['exit'] | null, visitor: string | null]} VisitorState
+*/
+const [visitorGetter, visitorSetter] = createStoreSerializable("visitorStatus", async (state) => {
+	if (!state) return null;
+	return { visitor: (await state)[3] };
+}, (val) => {
+	if (!val) return null;
+	const { visitor: visitorId } = val;
+	return Promise.resolve([
+		null,
+		null,
+		null,
+		visitorId
+	]);
+}, null);
+const visitors = LazyPromise.try(async function() {
+	return (await Array.fromAsync(loadPluginProfiles("visitor"))).map((v) => v[1]);
+});
+const existTesters = visitors.lazyThen((v) => v.map((v) => v.exist).filter((v) => typeof v === "function"));
+/**
+* 
+* @param {string} visitorId 
+* @returns {Promise<boolean>}
+*/
+async function existVisitor(visitorId) {
+	for (const fn of await existTesters) if (await fn(visitorId)) return true;
+	return false;
+}
+const getLoggedVisitorFn = visitors.lazyThen((list) => {
+	/** @type {[VisitorManager['get'], VisitorManager['set'] | null, VisitorManager['exit'] | null][]} */
+	const getLoggedVisitorFn = [];
+	for (const { get, set, exit } of list) {
+		if (typeof get !== "function") continue;
+		getLoggedVisitorFn.push([
+			get,
+			set || null,
+			exit || null
+		]);
+	}
+	return getLoggedVisitorFn;
+});
+const defaultLogin = visitors.lazyThen((v) => v.find((v) => typeof v.login === "function")?.login || null);
+/**
+* 
+* @returns {Promise<VisitorState>}
+*/
+async function getLoggedVisitor() {
+	/** @type {VisitorManager['set']?} */
+	let setVisitor = null;
+	/** @type {VisitorManager['exit']?} */
+	let exitVisitor = null;
+	/** @type {string?} */
+	let visitor = null;
+	for (const [get, set, exit] of await getLoggedVisitorFn) {
+		const u = await get();
+		if (!u || !await existVisitor(u)) continue;
+		visitor = u;
+		setVisitor = set;
+		exitVisitor = exit;
+		break;
+	}
+	if (!visitor) return [
+		null,
+		await defaultLogin,
+		null,
+		null
+	];
+	return [
+		null,
+		setVisitor,
+		exitVisitor,
+		visitor
+	];
+}
+async function get() {
+	let state = visitorGetter();
+	if (!state) {
+		state = getLoggedVisitor();
+		visitorSetter(state);
+	}
+	return state;
+}
+/**
+* 
+* @returns {Promise<string?>}
+*/
+function getVisitor() {
+	return get().then(([, , , current]) => current);
+}
+/**
+* 
+* @param {string?} visitorId
+* @returns {Promise<string?>}
+*/
+function setVisitor(visitorId) {
+	let state = Promise.resolve(visitorGetter() || getLoggedVisitor());
+	state = state.then(async ([, set, exit, current]) => {
+		if (!visitorId) {
+			if (current && exit) await exit(current);
+			return [
+				null,
+				set,
+				exit,
+				null
+			];
+		}
+		if (!set) return [
+			current,
+			set,
+			exit,
+			current
+		];
+		if (!await set(visitorId)) return [
+			null,
+			set,
+			exit,
+			current
+		];
+		return [
+			visitorId,
+			set,
+			exit,
+			visitorId
+		];
+	});
+	visitorSetter(state);
+	return state.then((v) => v[0]);
+}
+const finders = visitors.lazyThen((v) => v.map((v) => v.find).filter((v) => typeof v === "function"));
+/**
+* 
+* @param {Record<string, unknown>} loginName 
+* @returns {Promise<string>}
+*/
+async function findVisitor(loginName) {
+	for (const fn of await finders) {
+		const visitorId = await fn(loginName);
+		if (visitorId) return visitorId;
+	}
+	return "";
+}
+/**
+* 
+* @param {string} visitorId 
+* @returns {Promise<Record<string, any>>}
+*/
+async function loadVisitor(visitorId) {
+	return { id: visitorId };
+}
+
 //#endregion
 //#region packages/core/permission/createPermissionMatches.mjs
 /** @import { Permission } from '@yongdall/types' */
@@ -1009,18 +1239,21 @@ async function testPermissions(allPermissions, document) {
 //#endregion
 //#region packages/core/decorators/modelHook.mjs
 /** @import { Hooks, ClassDecorator } from '@yongdall/model' */
-/** @returns {{[K in keyof Hooks]: Record<string, Hooks[K][]>}} */
-function loadHooks() {
+/** @import { ModelProfile } from '../types.mjs' */
+const modelHooksPromise = LazyPromise.try(async function() {
 	/** @returns {{[K in keyof Hooks]: Record<string, Hooks[K][]>}} */
 	const modelHooks = Object.create(null);
-	for (const [, model, v] of hooks.get("modelHook").entriesObject()) for (const [name, fn] of Object.entries(v)) {
+	const list = await Array.fromAsync(loadPluginProfiles("model", function* ({ modelHook }) {
+		if (!modelHook || typeof modelHook !== "object" || Array.isArray(modelHook)) return;
+		yield* Object.entries(modelHook);
+	}));
+	for (const [model, v] of Object.entries(list)) for (const [name, fn] of Object.entries(v)) {
 		if (typeof fn !== "function") continue;
 		const list = modelHooks[name] ||= Object.create(null);
 		(list[model] ||= []).push(fn);
 	}
 	return modelHooks;
-}
-const modelHooks = loadHooks();
+});
 /**
 * 
 * @param  {Partial<Hooks>} hooks 
@@ -1034,6 +1267,7 @@ function bindModelHooks({ where, beforeCreateMany, afterCreateMany, beforeCreate
 		where: where || (() => {}),
 		async beforeCreateMany(conn, model, record) {
 			let data = record;
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.beforeCreateMany[name] || []) {
 				if (typeof hook !== "function") continue;
 				data = await hook(conn, model, data) || data;
@@ -1043,6 +1277,7 @@ function bindModelHooks({ where, beforeCreateMany, afterCreateMany, beforeCreate
 		},
 		async afterCreateMany(conn, model, record) {
 			if (typeof afterCreateMany === "function") await afterCreateMany(conn, model, record);
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.afterCreateMany[name] || []) {
 				if (typeof hook !== "function") continue;
 				await hook(conn, model, record);
@@ -1050,6 +1285,7 @@ function bindModelHooks({ where, beforeCreateMany, afterCreateMany, beforeCreate
 		},
 		async beforeCreate(conn, model, record) {
 			let data = record;
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.beforeCreate[name] || []) {
 				if (typeof hook !== "function") continue;
 				data = await hook(conn, model, data) || data;
@@ -1059,6 +1295,7 @@ function bindModelHooks({ where, beforeCreateMany, afterCreateMany, beforeCreate
 		},
 		async afterCreate(conn, model, record) {
 			if (typeof afterCreate === "function") await afterCreate(conn, model, record);
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.afterCreate[name] || []) {
 				if (typeof hook !== "function") continue;
 				await hook(conn, model, record);
@@ -1066,6 +1303,7 @@ function bindModelHooks({ where, beforeCreateMany, afterCreateMany, beforeCreate
 		},
 		async beforeUpdate(conn, model, record, set) {
 			let data = set;
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.beforeUpdate[name] || []) {
 				if (typeof hook !== "function") continue;
 				data = await hook(conn, model, record, data) || data;
@@ -1075,12 +1313,14 @@ function bindModelHooks({ where, beforeCreateMany, afterCreateMany, beforeCreate
 		},
 		async afterUpdate(conn, model, record, oldRecord) {
 			if (typeof afterUpdate === "function") await afterUpdate(conn, model, record, oldRecord);
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.afterUpdate[name] || []) {
 				if (typeof hook !== "function") continue;
 				await hook(conn, model, record, oldRecord);
 			}
 		},
 		async beforeDelete(conn, model, record, update) {
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.beforeDelete[name] || []) {
 				if (typeof hook !== "function") continue;
 				await hook(conn, model, record, update);
@@ -1089,6 +1329,7 @@ function bindModelHooks({ where, beforeCreateMany, afterCreateMany, beforeCreate
 		},
 		async afterDelete(conn, model, record, update) {
 			if (typeof afterDelete === "function") await afterDelete(conn, model, record, update);
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.afterDelete[name] || []) {
 				if (typeof hook !== "function") continue;
 				await hook(conn, model, record, update);
@@ -1108,6 +1349,7 @@ function modelHook(...hookNames) {
 		if (!names.length) return;
 		beforeCreateMany(Model, async (conn, model, record) => {
 			let data = record;
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.beforeCreateMany[name] || []) {
 				if (typeof hook !== "function") continue;
 				data = await hook(conn, model, data) || data;
@@ -1115,6 +1357,7 @@ function modelHook(...hookNames) {
 			return data;
 		});
 		afterCreateMany(Model, async (conn, model, record) => {
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.afterCreateMany[name] || []) {
 				if (typeof hook !== "function") continue;
 				await hook(conn, model, record);
@@ -1122,6 +1365,7 @@ function modelHook(...hookNames) {
 		});
 		beforeCreate(Model, async (conn, model, record) => {
 			let data = record;
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.beforeCreate[name] || []) {
 				if (typeof hook !== "function") continue;
 				data = await hook(conn, model, data) || data;
@@ -1129,6 +1373,7 @@ function modelHook(...hookNames) {
 			return data;
 		});
 		afterCreate(Model, async (conn, model, record) => {
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.afterCreate[name] || []) {
 				if (typeof hook !== "function") continue;
 				await hook(conn, model, record);
@@ -1136,6 +1381,7 @@ function modelHook(...hookNames) {
 		});
 		beforeUpdate(Model, async (conn, model, record, set) => {
 			let data = set;
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.beforeUpdate[name] || []) {
 				if (typeof hook !== "function") continue;
 				data = await hook(conn, model, record, data) || data;
@@ -1143,18 +1389,21 @@ function modelHook(...hookNames) {
 			return data;
 		});
 		afterUpdate(Model, async (conn, model, record, oldRecord) => {
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.afterUpdate[name] || []) {
 				if (typeof hook !== "function") continue;
 				await hook(conn, model, record, oldRecord);
 			}
 		});
 		beforeDelete(Model, async (conn, model, record, update) => {
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.beforeDelete[name] || []) {
 				if (typeof hook !== "function") continue;
 				await hook(conn, model, record, update);
 			}
 		});
 		afterDelete(Model, async (conn, model, record, update) => {
+			const modelHooks = await modelHooksPromise;
 			for (const name of names) for (const hook of modelHooks.afterDelete[name] || []) {
 				if (typeof hook !== "function") continue;
 				await hook(conn, model, record, update);
@@ -1167,14 +1416,17 @@ function modelHook(...hookNames) {
 //#region packages/core/ServerError.mjs
 var ServerError = class extends Error {
 	status = 500;
+	code = "";
 	/**
 	* 
-	* @param {string} message 
+	* @param {string | {code?: string; message: string; status?: number}} message 
 	* @param {number} [status] 
 	*/
 	constructor(message, status = 500) {
-		super(message);
-		this.status = status;
+		super(typeof message === "string" ? message : message.message);
+		const s = typeof message === "object" && message.status || status;
+		this.status = s;
+		this.code = typeof message === "object" && message.code || String(s);
 	}
 };
 
@@ -1359,20 +1611,24 @@ function toDocumentFields(fields) {
 //#endregion
 //#region packages/core/enumerations.mjs
 /** @import { MaybePromise } from './types.mjs' */
-/** @type {Record<string, (Record<string, any> | (() => MaybePromise<Record<string, any>[]>))[]>} */
-let enumerations = {};
-hooks.listen(() => {
-	const groups = Object.groupBy([...hooks.get("enumerations").values()].flatMap((v) => Object.entries(v)), ([k]) => k);
-	enumerations = Object.fromEntries(Object.entries(groups).map(([k, v]) => [k, v?.map((v) => v[1]).flat(2) || []]));
-}, -1e6);
+/** @type {Promise<Record<string, (Record<string, any> | (() => MaybePromise<Record<string, any>[]>))[]>>} */
+const enumerationsPromise = LazyPromise.try(async function() {
+	const list = await Array.fromAsync(loadPluginProfiles("enumeration", function* (c) {
+		yield* c && typeof c === "object" && !Array.isArray(c) ? Object.entries(c) : [];
+	}));
+	const groups = Object.groupBy(list, ([k]) => k);
+	return Object.fromEntries(Object.entries(groups).map(([k, v]) => [k, v?.map((v) => v[1]).flat(2) || []]));
+});
 /**
 * 
 * @param {string} name 
 * @returns {Promise<Record<string, any>[]>}
 */
 async function getEnumerations(name) {
-	if (!Object.hasOwn(enumerations, name)) return [];
-	return (await Promise.all(enumerations[name].map((v) => typeof v === "function" ? v() : v))).flat();
+	const allEnumerations = await enumerationsPromise;
+	if (!Object.hasOwn(allEnumerations, name)) return [];
+	const enumerations = allEnumerations[name].map((v) => typeof v === "function" ? v() : v);
+	return await Promise.all(enumerations).then((v) => v.flat());
 }
 
 //#endregion
@@ -1733,20 +1989,53 @@ async function search2where(fields, and, or, or2) {
 	}, fields, and, or, or2), execWhere, null);
 }
 
+//#endregion
+//#region packages/core/safe.mjs
+/**
+* 使用 HMAC-SHA256 对一个或多个值进行哈希，使用 salt 作为密钥。
+* 输出为 base64url 格式。
+*
+* @param {string | ArrayBuffer | ArrayBufferView<ArrayBuffer>} salt
+* @param {string | number} value
+* @param {...(string | number)} values
+* @returns {Promise<string>}
+*/
+async function hashSHA256(salt, value, ...values) {
+	/** @type {ArrayBuffer | ArrayBufferView<ArrayBuffer>} */
+	let keyBuffer;
+	if (salt instanceof ArrayBuffer || ArrayBuffer.isView(salt)) keyBuffer = salt;
+	else if (typeof salt === "string") keyBuffer = new TextEncoder().encode(salt);
+	else throw new Error("`salt` 参数必须为字符串或 Uint8Array");
+	const cryptoKey = await crypto.subtle.importKey("raw", keyBuffer, {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	/** @type {string[]} */
+	let data = [];
+	if (typeof value === "number") data.push(String(value));
+	else if (typeof value === "string") data.push(JSON.stringify(value).slice(1, -1));
+	else throw new Error("`value` 参数必须为字符串或数字");
+	for (const v of values) if (typeof v === "number") data.push(String(v));
+	else if (typeof v === "string") data.push(JSON.stringify(v).slice(1, -1));
+	const messageBuffer = new TextEncoder().encode(data.join("\n"));
+	const signature = await crypto.subtle.sign("HMAC", cryptoKey, messageBuffer);
+	return btoa(String.fromCharCode(...new Uint8Array(signature))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
 //#endregion
 //#region packages/core/index.mjs
 /**
 * 
-* @param {Partial<Omit<Tenant, 'id'>>} tenant 
+* @param {Partial<Omit<Realm, 'id'>>} realm 
 * @param {object} boot 
 * @param {Record<string, Partial<Hooks>>} pluginHooks 
 * @returns 
 */
-function initSystem(tenant, boot, pluginHooks) {
-	initConfig(tenant, boot);
+function initSystem(realm, boot, pluginHooks) {
+	initConfig(realm, boot);
 	Hook.update(hooks, pluginHooks);
 }
 
 //#endregion
-export { ServerError, bindModelHooks, bootConfiguration, createPermissionMatches, initSystem as default, existUser, filterPermissionDocument, filterPermissionUpdate, filterPermissions, findModel, findUser, getEnumerations, getMenus, getModel, getModelAuthorizationPermissions, getModelPermissions, getUser, getUserOrganizationAllPermissions, getUserOrganizationPermissions, getUserPermissions, hasUserOrganizationPermissions, hasUserPermission, hooks, initConfig, isSingleUser, loadPluginUser, loadUser, loadUserOrganizationAllPermissions, loadUserOrganizationPermissions, loadUserPermissions, mainTenant, modelHook, modelLoaders, models, nestedSetTree, search2where, setUser, setUserVerify, testPermissionConstraints, testPermissions, toDocumentFields, useTenant, verifyUser };
+export { ServerError, bindModelHooks, bootConfiguration, createPermissionMatches, initSystem as default, existUser, existVisitor, filterPermissionDocument, filterPermissionUpdate, filterPermissions, findModel, findUser, findVisitor, getEnumerations, getMenus, getModel, getModelAuthorizationPermissions, getModelPermissions, getUser, getUserOrganizationAllPermissions, getUserOrganizationPermissions, getUserPermissions, getVisitor, hasUserOrganizationPermissions, hasUserPermission, hashSHA256, hooks, initConfig, isSingleUser, loadPluginUser, loadUser, loadUserOrganizationAllPermissions, loadUserOrganizationPermissions, loadUserPermissions, loadVisitor, mainRealm, mainTenant, modelHook, nestedSetTree, search2where, setUser, setUserVerify, setVisitor, testPermissionConstraints, testPermissions, toDocumentFields, useRealm, useSalt, useTenant, verifyUser };
 //# sourceMappingURL=index.mjs.map