@yongdall/core 0.1.0

package/index.mjs

@@ -0,0 +1,1709 @@
+import { Hook, 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";
+
+//#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 { BootConfiguration } from '@yongdall/common' */
+/** @type {Tenant} */
+const mainTenant = {
+	id: "",
+	label: "拥道YongDall",
+	single: false,
+	providers: {},
+	salt: "YongDall"
+};
+/** @type {BootConfiguration} */
+const bootConfiguration = {
+	pages: {},
+	theme: "@yongdall/theme#allSider",
+	authenticator: "",
+	path: "/workbench/"
+};
+/**
+* 
+* @param {Partial<Omit<Tenant, 'id'>>} tenant 
+* @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));
+}
+
+//#endregion
+//#region packages/core/hooks.mjs
+/** @import { Hooks } from './types.mjs' */
+/** @type {Hook<Hooks>} */
+const hooks = new Hook();
+
+//#endregion
+//#region packages/core/menu.mjs
+/**
+* 
+* @param {string} type 
+* @param {string} [group] 
+* @returns 
+*/
+function getMenus(type, group = "") {
+	return [];
+}
+
+//#endregion
+//#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) => {
+		if (!v || typeof v !== "object" || Array.isArray(v)) return [];
+		return Object.entries(v).map(([fieldName, field]) => [
+			modelId,
+			fieldName,
+			field
+		]);
+	}));
+	const groups = Object.groupBy(modelFields, (v) => v[0]);
+	/** @type {Record<string, Fields<TableDefine>>} */
+	const expands = {};
+	for (const [modelId, fields] of Object.entries(groups)) {
+		if (!fields?.length) continue;
+		expands[modelId] = Object.fromEntries(fields.map(([, fieldName, field]) => [fieldName, field]));
+	}
+	modelExpands = expands;
+}, -1e6);
+/**
+* 
+* @param {string | string[]} ident 
+* @returns {Promise<ModelTable?>}
+*/
+async function findModel(ident) {
+	const [model, ...collection] = (Array.isArray(ident) ? ident : ident.split(":")).filter(Boolean);
+	if (!collection.length) {
+		const define = Object.hasOwn(models, model) && models[model];
+		return typeof define === "object" && define || null;
+	}
+	const loader = Object.hasOwn(modelLoaders, model) && modelLoaders[model];
+	if (typeof loader !== "function") return null;
+	const define = await loader(collection);
+	return typeof define === "object" && define || null;
+}
+/**
+* 
+* @param {string | string[]} ident 
+* @returns {Promise<ModelTable?>}
+*/
+async function getModel(ident) {
+	const model = await findModel(ident);
+	if (!model) return model;
+	const define = modelMap.get(model);
+	if (define) return define;
+	const modelIdent = Array.isArray(ident) ? ident.join(":") : ident;
+	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) {
+		const permissions = await fn(modelId, groupId);
+		if (permissions) return permissions;
+	}
+	if (groupId) return null;
+	return getDefinePermission(await getModel(modelId));
+}, (modelId, groupId) => [modelId, groupId || ""].join("\n"));
+/**
+* 
+* @param {string} modelId 
+* @param {string} authorization
+* @param {string?} [groupId] 
+* @returns {Promise<Permission[]?>}
+*/
+async function getModelAuthorizationPermissions(modelId, authorization, groupId) {
+	const permissions = await getModelPermissions(modelId, groupId);
+	if (!permissions?.length) return permissions;
+	return permissions.filter(({ authorizations }) => {
+		if (!authorizations) return false;
+		if (Array.isArray(authorizations)) return authorizations.includes(authorization);
+		if (authorizations instanceof Set) return authorizations.has(authorization);
+		return false;
+	});
+}
+
+//#endregion
+//#region packages/core/tenant.mjs
+/** @import { Tenant } from '@yongdall/types' */
+const [tenantGetter, tenantSetter] = createStoreSerializable("tenantStatus", async (state) => {
+	if (!state) return null;
+	return state;
+}, (tenant) => {
+	return tenant ? Promise.resolve(tenant) : null;
+}, null);
+function getTenantManager() {
+	return [...hooks.get("tenantManager").values()].filter(Boolean);
+}
+let tenantManagers = getTenantManager();
+hooks.listen(() => {
+	tenantManagers = getTenantManager();
+}, -1e6);
+/**
+* 
+* @returns {Promise<Tenant>}
+*/
+async function getCurrentTenant() {
+	if (!tenantManagers.length) return mainTenant;
+	for (const get of tenantManagers) {
+		const u = await get();
+		if (!u) continue;
+		return u;
+	}
+	throw new Error("[noTenant] 找不到租户");
+}
+async function get$1() {
+	let state = tenantGetter();
+	if (!state) {
+		state = getCurrentTenant();
+		tenantSetter(state);
+	}
+	return state;
+}
+/**
+* 
+* @returns {Promise<Tenant>}
+*/
+function useTenant() {
+	return get$1();
+}
+
+//#endregion
+//#region packages/core/user.mjs
+/** @import { Tenant } 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
+*/
+const [userGetter, userSetter] = createStoreSerializable("userStatus", async (state) => {
+	if (!state) return null;
+	const s = await state;
+	return {
+		user: s[3],
+		sUser: s[4]
+	};
+}, (val) => {
+	if (!val) return null;
+	const { user: userId, sUser: sUserId } = val;
+	return Promise.resolve([
+		null,
+		null,
+		null,
+		userId,
+		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 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 {string} user 
+	* @param {string} sUser 
+	* @returns {Promise<boolean>}
+	*/
+	async function switchable(tenant, 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);
+/**
+* 
+* @param {string} userId 
+* @param {boolean} [login] 
+* @returns {Promise<boolean>}
+*/
+async function existUser(userId, login) {
+	for (const fn of existTesters) if (await fn(userId, login)) return true;
+	return false;
+}
+/**
+* 
+* @returns {Promise<State>}
+*/
+async function getLoggedUser() {
+	const tenant = await useTenant();
+	if (tenant.single) {
+		for (const suGet of suGets) {
+			const suUser = await suGet();
+			if (!suUser) continue;
+			if (!await existUser(suUser)) continue;
+			return [
+				null,
+				null,
+				null,
+				null,
+				suUser
+			];
+		}
+		return [
+			null,
+			null,
+			null,
+			null,
+			null
+		];
+	}
+	/** @type {UserManager['set']?} */
+	let setUser = null;
+	/** @type {UserManager['exit']?} */
+	let exitUser = null;
+	/** @type {string?} */
+	let user = null;
+	for (const [get, set, exit] of getLoggedUserFn) {
+		const u = await get();
+		if (!u || !await existUser(u)) continue;
+		user = u;
+		setUser = set;
+		exitUser = exit;
+		break;
+	}
+	if (!user) return [
+		null,
+		defaultLogin,
+		null,
+		null,
+		null
+	];
+	for (const suGet of suGets) {
+		const suUser = await suGet();
+		if (!suUser) continue;
+		if (!await existUser(suUser)) continue;
+		if (await switchable(tenant, user, suUser)) continue;
+		return [
+			null,
+			setUser,
+			exitUser,
+			user,
+			suUser
+		];
+	}
+	return [
+		null,
+		setUser,
+		exitUser,
+		user,
+		null
+	];
+}
+async function get() {
+	let state = userGetter();
+	if (!state) {
+		state = getLoggedUser();
+		userSetter(state);
+	}
+	return state;
+}
+/**
+* @param {boolean} [logged] 
+* @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));
+}
+/**
+* 
+* @param {boolean?} [logged] 是否为登陆用户
+* @returns {Promise<string?>}
+*/
+function getUser(logged) {
+	return get().then(([, , , current, su]) => {
+		if (logged === false) return su;
+		if (logged) return current;
+		return su || current;
+	});
+}
+/**
+* 
+* @param {string?} userId
+* @param {boolean?} [sudo]
+* @returns {Promise<string?>}
+*/
+function setUser(userId, sudo) {
+	let state = Promise.resolve(userGetter() || getLoggedUser());
+	if (sudo) state = state.then(async ([, set, exit, current]) => {
+		if (!userId || !await existUser(userId)) return [
+			null,
+			set,
+			exit,
+			current,
+			null
+		];
+		if (current || await useTenant().then((t) => t.single)) return [
+			userId,
+			set,
+			exit,
+			current,
+			userId
+		];
+		return [
+			null,
+			set,
+			exit,
+			null,
+			null
+		];
+	});
+	else state = state.then(async ([, set, exit, current, su]) => {
+		if (!userId) {
+			if (current && exit) await exit(current);
+			return [
+				null,
+				set,
+				exit,
+				null,
+				null
+			];
+		}
+		if (!set) return [
+			current,
+			set,
+			exit,
+			current,
+			su
+		];
+		if ((await useTenant()).single) return [
+			null,
+			set,
+			exit,
+			null,
+			su
+		];
+		if (!await set(userId)) return [
+			null,
+			set,
+			exit,
+			current,
+			su
+		];
+		return [
+			userId,
+			set,
+			exit,
+			userId,
+			null
+		];
+	});
+	userSetter(state);
+	return state.then((v) => v[0]);
+}
+/**
+* 
+* @param {string | Record<string, unknown>} loginName 
+* @param {string | string[]} [loginType] 
+* @returns {Promise<string>}
+*/
+async function findUser(loginName, loginType) {
+	const types = new Set([loginType || ""].flat().filter(Boolean));
+	for (const fn of finders) {
+		const userId = await fn(loginName, types);
+		if (userId) return userId;
+	}
+	return "";
+}
+/**
+* 
+* @param {string} userId 
+* @param {string} password 
+* @param {string} type 
+* @param {boolean} [returnError] 
+* @returns {Promise<number>}
+*/
+async function verifyUser(userId, password, type, returnError) {
+	for (const fn of verifiers[type] || []) {
+		const res = await fn(userId, password);
+		if (res < 0) return returnError ? res : 0;
+		if (res > 0) return res;
+	}
+	return 0;
+}
+/**
+* 
+* @param {string} userId 
+* @param {string} type 
+* @param {string?} password 
+* @param {Date?} [deadline] 
+* @returns {Promise<boolean>}
+*/
+async function setUserVerify(userId, type, password, deadline) {
+	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) {
+		const r = await f(user);
+		if (r) return new Set(r);
+	}
+	return /* @__PURE__ */ new Set();
+}, (user) => user || "");
+/**
+* 
+* @param {boolean?} [logged] 是否为登陆用户
+* @returns {Promise<Set<string>>}
+*/
+async function getUserPermissions(logged) {
+	return loadUserPermissions(await getUser(logged));
+}
+/** @type {(user?: string?) => Promise<Set<string>>} */
+const loadUserOrganizationAllPermissions = createKeyStore(async (user) => {
+	if (!user) return /* @__PURE__ */ new Set();
+	for (const f of getOrganizationAllPermissions) {
+		const r = await f(user);
+		if (r) return new Set(r);
+	}
+	return /* @__PURE__ */ new Set();
+}, (user) => user || "");
+/**
+* 
+* @param {boolean?} [logged] 是否为登陆用户
+* @returns {Promise<Set<string>>}
+*/
+async function getUserOrganizationAllPermissions(logged) {
+	return loadUserOrganizationAllPermissions(await getUser(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) {
+		const r = await f(user);
+		if (r) return Object.fromEntries(Object.entries(r).map(([k, v]) => [k, new Set(v)]));
+	}
+	return Object.create(null);
+}, (user) => user || "");
+/**
+* 
+* @param {boolean?} [logged] 是否为登陆用户
+* @returns {Promise<Record<string, Set<string>>>}
+*/
+async function getUserOrganizationPermissions(logged) {
+	return loadUserOrganizationPermissions(await getUser(logged));
+}
+/**
+* 
+* @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)])));
+	return Object.fromEntries(Object.entries(Object.groupBy(list2, ([k]) => k)).map(([k, l]) => {
+		return [k, Object.assign({}, ...l?.map((v) => v[1]) || [])];
+	}));
+}
+/**
+* 
+* @param {string} userId 
+* @returns {Promise<Record<string, any>>}
+*/
+async function loadUser(userId, plugin = false) {
+	const [list, plugins, permissions] = await Promise.all([
+		Promise.all(loaders.map((f) => f(userId))),
+		plugin ? loadPluginUser(userId) : {},
+		loadUserPermissions(userId).then((p) => [...p])
+	]);
+	return Object.assign({}, ...list, {
+		id: userId,
+		plugins,
+		permissions
+	});
+}
+
+//#endregion
+//#region packages/core/permission/createPermissionMatches.mjs
+/** @import { Permission } from '@yongdall/types' */
+/**
+*
+* @param {Exclude<Permission['constraints'], void>?} [constraints]
+* @param {string?} [userId]
+* @returns {Iterable<[string, string, any]>}
+*/
+function* yieldConstraintWheres(constraints, userId) {
+	if (!constraints) return;
+	for (const [field, constraint] of Object.entries(constraints)) {
+		if (!constraint) continue;
+		const { value, values, user } = constraint;
+		if (value !== void 0) yield [
+			field,
+			"=",
+			value
+		];
+		else if (Array.isArray(values) && values.length) yield [
+			field,
+			"in",
+			values
+		];
+		else if (values instanceof Set && values.size) yield [
+			field,
+			"in",
+			[...values]
+		];
+		else if (user && userId) yield [
+			field,
+			"=",
+			userId
+		];
+	}
+}
+/**
+* @param {Permission[]} permissions
+*/
+async function createPermissionMatches(permissions) {
+	let permissionInGlobal = permissions.filter((v) => !v.organizationField);
+	const orWhere = new Where();
+	if (permissionInGlobal.length) {
+		const permissions = await getUserPermissions();
+		permissionInGlobal = permissionInGlobal.filter((v) => !v.permission || permissions.has(v.permission));
+	}
+	const userId = await getUser();
+	for (const { constraints } of permissionInGlobal) {
+		const wheres = [...yieldConstraintWheres(constraints, userId)];
+		if (!wheres.length) return null;
+		const where = new Where();
+		for (const v of wheres) where.and(...v);
+		orWhere.or(where);
+	}
+	let permissionInOrganization = permissions.filter((v) => v.organizationField);
+	if (permissionInOrganization.length) {
+		const organizationPermissions = await getUserOrganizationAllPermissions();
+		permissionInOrganization = permissionInOrganization.filter((v) => !v.permission || organizationPermissions.has(v.permission));
+	}
+	if (!permissionInOrganization.length) return orWhere;
+	if (permissionInOrganization.length) {
+		const organizationPermissions = Object.entries(await getUserOrganizationPermissions());
+		for (const { constraints, permission, organizationField } of permissionInOrganization) {
+			const organizations = permission ? organizationPermissions.filter((v) => v[1].has(permission)).map((v) => v[0]) : organizationPermissions.map((v) => v[0]);
+			if (!organizations.length) continue;
+			const where = Where.and(organizationField || "", "in", organizations);
+			for (const v of yieldConstraintWheres(constraints, userId)) where.and(...v);
+			orWhere.or(where);
+		}
+	}
+	return orWhere;
+}
+
+//#endregion
+//#region packages/core/permission/testPermissionConstraints.mjs
+/** @import { Permission } from '@yongdall/types' */
+/**
+*
+* @param {Exclude<Permission['constraints'], void>} constraints
+* @param {Record<string, any>} document
+* @param {string?} userId
+*/
+function testPermissionConstraints(constraints, document, userId) {
+	for (const [field, constraint] of Object.entries(constraints)) {
+		if (!constraint) continue;
+		const { value, values, user } = constraint;
+		const val = document[field];
+		if (value !== void 0) {
+			if (val !== value) return false;
+		} else if (Array.isArray(values) && values.length) {
+			if (!values.includes(val)) return false;
+		} else if (values instanceof Set && values.size) {
+			if (!values.has(val)) return false;
+		} else if (user) {
+			if (val !== userId) return false;
+		}
+	}
+	return true;
+}
+
+//#endregion
+//#region packages/core/permission/filterPermissions.mjs
+/** @import { Permission } from '@yongdall/types' */
+/**
+*
+* @param {Permission[]} allPermissions
+* @param {Record<string, any>} document
+* @returns
+*/
+async function filterPermissions(allPermissions, document) {
+	const permissionInGlobal = allPermissions.filter((v) => !v.organizationField);
+	const permissionInOrganization = allPermissions.filter((v) => v.organizationField);
+	/** @type {Permission[]} */
+	const filteredPermissions = [];
+	const userId = await getUser();
+	if (permissionInGlobal.length) {
+		const permissions = await getUserPermissions();
+		for (const p of permissionInGlobal) {
+			const { permission, constraints } = p;
+			if (permission && !permissions.has(permission)) continue;
+			if (constraints && !testPermissionConstraints(constraints, document, userId)) continue;
+			filteredPermissions.push(p);
+		}
+	}
+	if (permissionInOrganization.length) {
+		const permissions = await getUserOrganizationPermissions();
+		for (const p of permissionInOrganization) {
+			const { permission, organizationField, constraints } = p;
+			if (constraints && !testPermissionConstraints(constraints, document, userId)) continue;
+			const organizationId = document[organizationField || ""];
+			if (!organizationId) continue;
+			const organizationPermissions = permissions[organizationId];
+			if (!organizationPermissions) continue;
+			if (permission && !organizationPermissions.has(permission)) continue;
+			filteredPermissions.push(p);
+		}
+	}
+	return filteredPermissions;
+}
+
+//#endregion
+//#region packages/core/permission/filterPermissionDocument.mjs
+/** @import { Permission } from '@yongdall/types' */
+/** @import { ModelTable, FieldDefine } from '@yongdall/model' */
+/**
+* @param {ModelTable} model
+* @param {Permission[]} permissions
+* @param {Record<string, any>} document
+*/
+async function filterPermissionDocument({ fields }, permissions, document) {
+	const userPermissions = await filterPermissions(permissions, document);
+	if (userPermissions && !userPermissions.length) return null;
+	let groups = new Set(userPermissions.flatMap((v) => v.group || ""));
+	let fieldsAuth = new Set(userPermissions.flatMap((v) => v.fields || ""));
+	groups.delete("");
+	fieldsAuth.delete("");
+	if (!(groups.size + fieldsAuth.size)) return null;
+	/**
+	*
+	* @param {[string, FieldDefine & {group?: string}][]} fields
+	* @param {Record<string, any>} document
+	* @param {string[]} parent
+	* @returns
+	*/
+	function filter(fields, document, parent) {
+		/** @type {Record<string, any>} */
+		const value = {};
+		for (const [name, field] of fields) {
+			if (!field) continue;
+			const fieldNames = [...parent, name];
+			const key = fieldNames.join(".");
+			if (!field.primary && !groups.has(field.group || "") && !fieldsAuth.has(key) && !fieldsAuth.has("*")) continue;
+			const { type } = field;
+			if (!type || typeof type !== "object" || !type.table) {
+				value[name] = document[name];
+				continue;
+			}
+			const subDocument = document[name];
+			const list = Object.entries(type.fields);
+			if (field.array) value[name] = (Array.isArray(subDocument) ? subDocument : subDocument ? [subDocument] : []).map((doc) => filter(list, doc, key));
+			else if (subDocument && !Array.isArray(subDocument)) {
+				const val = filter(list, subDocument, fieldNames);
+				if (!Object.keys(val)) continue;
+				value[name] = val;
+			}
+		}
+		return value;
+	}
+	return filter(Object.entries(fields), document, []);
+}
+
+//#endregion
+//#region packages/core/permission/filterPermissionUpdate.mjs
+/** @import { FieldDefine, ModelTable } from '@yongdall/model' */
+/** @import { Permission } from '@yongdall/types' */
+/**
+* @param {ModelTable} model
+* @param {Permission[]} permissions
+* @param {Record<string, any>} document
+* @param {Record<string, any>} newDocument
+*/
+async function filterPermissionUpdate({ fields }, permissions, document, newDocument) {
+	let newData = newDocument;
+	const userPermissions = await filterPermissions(permissions, {
+		...document,
+		...newData
+	});
+	if (userPermissions && !userPermissions.length) return null;
+	let groups = new Set(userPermissions.flatMap((v) => v.group || ""));
+	let fieldsAuth = new Set(userPermissions.flatMap((v) => v.fields || ""));
+	groups.delete("");
+	fieldsAuth.delete("");
+	while (groups.size + fieldsAuth.size) {
+		const oldData = newData;
+		newData = {};
+		for (const [key, value] of Object.entries(oldData)) {
+			/** @type {FieldDefine & {group?: string}?} */
+			const field = fields[key];
+			if (!field) continue;
+			if (!groups.has(field.group || "") && !fieldsAuth.has(key)) continue;
+			newData[key] = value;
+		}
+		const newPermissionGroups = await filterPermissions(permissions, {
+			...document,
+			...newData
+		});
+		if (newPermissionGroups && !newPermissionGroups.length) return null;
+		const newGroups = new Set(newPermissionGroups.flatMap((v) => v.group || ""));
+		const newFieldsAuth = new Set(newPermissionGroups.flatMap((v) => v.fields || ""));
+		newGroups.delete("");
+		newFieldsAuth.delete("");
+		if (newGroups.size === groups.size && newFieldsAuth.size === fieldsAuth.size) break;
+		groups = newGroups;
+		fieldsAuth = newFieldsAuth;
+	}
+	if (!(groups.size + fieldsAuth.size)) return null;
+	/**
+	*
+	* @param {[string, FieldDefine & {group?: string}][]} fields
+	* @param {Record<string, any>} document
+	* @param {string[]} parent
+	* @returns
+	*/
+	function filter(fields, document, parent) {
+		/** @type {Record<string, any>} */
+		const value = {};
+		for (const [name, field] of fields) {
+			if (!field) continue;
+			const fieldNames = [...parent, name];
+			const key = fieldNames.join(".");
+			if ((parent ? !field.primary : true) && !groups.has(field.group || "") && !fieldsAuth.has(key) && !fieldsAuth.has("*")) continue;
+			if (!Object.hasOwn(document, name)) continue;
+			const { type } = field;
+			if (!type || typeof type !== "object" || !type.table) {
+				value[name] = document[name];
+				continue;
+			}
+			const subDocument = document[name];
+			const list = Object.entries(type.fields);
+			if (field.array) value[name] = (Array.isArray(subDocument) ? subDocument : [subDocument]).map((doc) => filter(list, doc, fieldNames));
+			else if (subDocument && !Array.isArray(subDocument)) {
+				const val = filter(list, subDocument, fieldNames);
+				if (!Object.keys(val)) continue;
+				value[name] = val;
+			}
+		}
+		return value;
+	}
+	return filter(Object.entries(fields), newDocument, []);
+}
+
+//#endregion
+//#region packages/core/permission/testPermissions.mjs
+/** @import { Permission } from '@yongdall/types' */
+/**
+*
+* @param {Permission[]?} [allPermissions]
+* @param {Record<string, any>} [document]
+* @returns
+*/
+async function testPermissions(allPermissions, document) {
+	if (await isSingleUser()) return true;
+	if (!allPermissions?.length) return false;
+	const permissionInGlobal = allPermissions.filter((v) => !v.organizationField);
+	const permissionInOrganization = allPermissions.filter((v) => v.organizationField);
+	if (!document) {
+		if (permissionInGlobal.length) {
+			const permissions = await getUserPermissions();
+			for (const { permission } of permissionInGlobal) {
+				if (permission && !permissions.has(permission)) continue;
+				return true;
+			}
+		}
+		if (permissionInOrganization.length) {
+			const permissions = await getUserOrganizationAllPermissions();
+			for (const { permission } of permissionInOrganization) {
+				if (permission && !permissions.has(permission)) continue;
+				return true;
+			}
+		}
+		return false;
+	}
+	const userId = await getUser();
+	if (permissionInGlobal.length) {
+		const permissions = await getUserPermissions();
+		for (const { permission, constraints } of permissionInGlobal) {
+			if (permission && !permissions.has(permission)) continue;
+			if (constraints && !testPermissionConstraints(constraints, document, userId)) continue;
+			return true;
+		}
+	}
+	if (permissionInOrganization.length) {
+		const permissions = await getUserOrganizationPermissions();
+		for (const { permission, organizationField, constraints } of permissionInOrganization) {
+			if (constraints && !testPermissionConstraints(constraints, document, userId)) continue;
+			const organizationId = document[organizationField || ""];
+			if (!organizationId) continue;
+			const organizationPermissions = permissions[organizationId];
+			if (!organizationPermissions) continue;
+			if (permission && !organizationPermissions.has(permission)) continue;
+			return true;
+		}
+	}
+	return false;
+}
+
+//#endregion
+//#region packages/core/decorators/modelHook.mjs
+/** @import { Hooks, ClassDecorator } from '@yongdall/model' */
+/** @returns {{[K in keyof Hooks]: Record<string, Hooks[K][]>}} */
+function loadHooks() {
+	/** @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)) {
+		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 
+* @param  {...string | string[]} hookNames 
+* @returns {Hooks}
+*/
+function bindModelHooks({ where, beforeCreateMany, afterCreateMany, beforeCreate, afterCreate, beforeUpdate, afterUpdate, beforeDelete, afterDelete }, ...hookNames) {
+	/** @type {string[]} */
+	const names = hookNames.flat(21);
+	return {
+		where: where || (() => {}),
+		async beforeCreateMany(conn, model, record) {
+			let data = record;
+			for (const name of names) for (const hook of modelHooks.beforeCreateMany[name] || []) {
+				if (typeof hook !== "function") continue;
+				data = await hook(conn, model, data) || data;
+			}
+			if (typeof beforeCreateMany === "function") data = await beforeCreateMany(conn, model, data) || data;
+			return data;
+		},
+		async afterCreateMany(conn, model, record) {
+			if (typeof afterCreateMany === "function") await afterCreateMany(conn, model, record);
+			for (const name of names) for (const hook of modelHooks.afterCreateMany[name] || []) {
+				if (typeof hook !== "function") continue;
+				await hook(conn, model, record);
+			}
+		},
+		async beforeCreate(conn, model, record) {
+			let data = record;
+			for (const name of names) for (const hook of modelHooks.beforeCreate[name] || []) {
+				if (typeof hook !== "function") continue;
+				data = await hook(conn, model, data) || data;
+			}
+			if (typeof beforeCreate === "function") data = await beforeCreate(conn, model, data) || data;
+			return data;
+		},
+		async afterCreate(conn, model, record) {
+			if (typeof afterCreate === "function") await afterCreate(conn, model, record);
+			for (const name of names) for (const hook of modelHooks.afterCreate[name] || []) {
+				if (typeof hook !== "function") continue;
+				await hook(conn, model, record);
+			}
+		},
+		async beforeUpdate(conn, model, record, set) {
+			let data = set;
+			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;
+			}
+			if (typeof beforeUpdate === "function") data = await beforeUpdate(conn, model, record, data) || data;
+			return data;
+		},
+		async afterUpdate(conn, model, record, oldRecord) {
+			if (typeof afterUpdate === "function") await afterUpdate(conn, model, record, oldRecord);
+			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) {
+			for (const name of names) for (const hook of modelHooks.beforeDelete[name] || []) {
+				if (typeof hook !== "function") continue;
+				await hook(conn, model, record, update);
+			}
+			if (typeof beforeDelete === "function") await beforeDelete(conn, model, record, update);
+		},
+		async afterDelete(conn, model, record, update) {
+			if (typeof afterDelete === "function") await afterDelete(conn, model, record, update);
+			for (const name of names) for (const hook of modelHooks.afterDelete[name] || []) {
+				if (typeof hook !== "function") continue;
+				await hook(conn, model, record, update);
+			}
+		}
+	};
+}
+/**
+* 
+* @param  {...string | string[]} hookNames 
+* @returns {ClassDecorator}
+*/
+function modelHook(...hookNames) {
+	/** @type {string[]} */
+	const names = hookNames.flat(21);
+	return (Model, ctx) => {
+		if (!names.length) return;
+		beforeCreateMany(Model, async (conn, model, record) => {
+			let data = record;
+			for (const name of names) for (const hook of modelHooks.beforeCreateMany[name] || []) {
+				if (typeof hook !== "function") continue;
+				data = await hook(conn, model, data) || data;
+			}
+			return data;
+		});
+		afterCreateMany(Model, async (conn, model, record) => {
+			for (const name of names) for (const hook of modelHooks.afterCreateMany[name] || []) {
+				if (typeof hook !== "function") continue;
+				await hook(conn, model, record);
+			}
+		});
+		beforeCreate(Model, async (conn, model, record) => {
+			let data = record;
+			for (const name of names) for (const hook of modelHooks.beforeCreate[name] || []) {
+				if (typeof hook !== "function") continue;
+				data = await hook(conn, model, data) || data;
+			}
+			return data;
+		});
+		afterCreate(Model, async (conn, model, record) => {
+			for (const name of names) for (const hook of modelHooks.afterCreate[name] || []) {
+				if (typeof hook !== "function") continue;
+				await hook(conn, model, record);
+			}
+		});
+		beforeUpdate(Model, async (conn, model, record, set) => {
+			let data = set;
+			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;
+			}
+			return data;
+		});
+		afterUpdate(Model, async (conn, model, record, oldRecord) => {
+			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) => {
+			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) => {
+			for (const name of names) for (const hook of modelHooks.afterDelete[name] || []) {
+				if (typeof hook !== "function") continue;
+				await hook(conn, model, record, update);
+			}
+		});
+	};
+}
+
+//#endregion
+//#region packages/core/ServerError.mjs
+var ServerError = class extends Error {
+	status = 500;
+	/**
+	* 
+	* @param {string} message 
+	* @param {number} [status] 
+	*/
+	constructor(message, status = 500) {
+		super(message);
+		this.status = status;
+	}
+};
+
+//#endregion
+//#region packages/core/decorators/nestedSetTree.mjs
+/**
+* 
+* @param {Connection} conn 
+* @param {any} Model 
+* @param {number} id 
+* @param {number} lftValue 
+* @param {number} rgtValue 
+* @param {string} idField 
+* @param {string} lftField 
+* @param {string} rgtField 
+*/
+async function treeValidateLoop(conn, Model, id, lftValue, rgtValue, idField, lftField, rgtField) {
+	if ((await conn.select(new Query(Model).select(idField).where(lftField, "<=", lftValue).where(rgtField, ">=", rgtValue).where({ [idField]: id }).limit(1))).length) throw new ServerError("项目不能被添加到自己的后代");
+}
+/**
+* 
+* @param {string} parentField 
+* @param {string} lftField 
+* @param {string} rgtField 
+* @param {string} idField 
+* @param {...string} groupFields 
+*/
+function nestedSetTree(parentField, lftField = "lft", rgtField = "rgt", idField = "id", ...groupFields) {
+	/**
+	* 
+	* @param {any} Model 
+	* @param {ClassDecoratorContext} ctx 
+	*/
+	return function(Model, ctx) {
+		beforeCreate(Model, async (conn, record) => {
+			let begin = 1;
+			const parent = record[parentField];
+			const where = new Where();
+			for (const g of groupFields) where.and(g, record[g]);
+			if (parent) {
+				const [{ [rgtField]: rgtValue }] = await conn.select(new Query(Model, true).select(rgtField).where(where).where({ [idField]: parent }).limit(1));
+				begin = rgtValue;
+				await conn.update(new Query(Model).where(where).where(rgtField, ">=", begin), { [rgtField]: increment(2) });
+				await conn.update(new Query(Model).where(where).where(lftField, ">=", begin), { [lftField]: increment(2) });
+			} else {
+				/** @type {{r: number}[]} */
+				const [{ r } = { r: 0 }] = await conn.select(new Query(Model, true).select({ r: rgtField }).where(where).where({ [idField]: parent }).limit(1).sort(rgtField, true));
+				begin = r + 1;
+			}
+			record[lftField] = begin;
+			record[rgtField] = begin + 1;
+		}, true);
+		beforeUpdate(Model, async (conn, oldDocument, updatedData) => {
+			const parentId = parentField in updatedData ? updatedData[parentField] : oldDocument[parentField];
+			if (parentId === oldDocument[parentField]) {
+				updatedData[lftField] = oldDocument[lftField];
+				updatedData[rgtField] = oldDocument[rgtField];
+				return;
+			}
+			const where = new Where();
+			for (const g of groupFields) where.and(g, updatedData[g] ?? oldDocument[g]);
+			if (parentId) {
+				const [parent] = await conn.select(new Query(Model).select({
+					lft: lftField,
+					rgt: rgtField
+				}).where(where).where({ [idField]: parentId }));
+				const { lft, rgt } = parent;
+				await treeValidateLoop(conn, Model, oldDocument[idField], lft, rgt, idField, lftField, rgtField);
+			}
+			await conn.update(new Query(Model).where(where).where(lftField, ">=", oldDocument[rgtField]).where(rgtField, "<=", oldDocument[rgtField]), {
+				[rgtField]: multiply(-1),
+				[rgtField]: multiply(-1)
+			});
+			const diff = oldDocument[rgtField] - oldDocument[lftField] + 1;
+			await conn.update(new Query(Model).where(where).where(lftField, ">", oldDocument[rgtField]), { [lftField]: decrement(diff) });
+			await conn.update(new Query(Model).where(where).where(rgtField, ">", oldDocument[rgtField]), { [rgtField]: decrement(diff) });
+			let newLft = 0;
+			if (parentId) {
+				const [{ [rgtField]: rgtValue }] = await conn.select(new Query(Model).select(rgtField).where(where).where({ [idField]: parentId }));
+				await conn.update(new Query(Model).where(where).where(rgtField, ">=", rgtValue), { [rgtField]: increment(diff) });
+				await conn.update(new Query(Model).where(where).where(lftField, ">=", rgtValue), { [lftField]: increment(diff) });
+				newLft = rgtValue;
+			} else {
+				/** @type {{r: number}[]} */
+				const [{ r } = { r: 0 }] = await conn.select(new Query(Model, true).select({ r: rgtField }).where(where).where({ [idField]: parent }).limit(1).sort(rgtField, true));
+				newLft = r + 1;
+			}
+			const val = newLft - oldDocument[lftField];
+			await conn.update(new Query(Model).where(where).where(lftField, "<", 0), {
+				[lftField]: coefficient(val, -1),
+				[rgtField]: coefficient(val, -1)
+			});
+			updatedData[lftField] = oldDocument[lftField] + val;
+			updatedData[rgtField] = oldDocument[rgtField] + val;
+		}, true);
+	};
+}
+
+//#endregion
+//#region packages/core/toDocumentFields.mjs
+/** @import { Field } from '@yongdall/types' */
+/** @import { FieldDefine } from '@yongdall/model' */
+/**
+* 
+* @param {Record<string, FieldDefine>} fields 
+* @param {Set<string>} ignore 
+* @returns {Record<string, Field>?}
+*/
+function toSubDocumentFields(fields, ignore) {
+	/** @type {Record<string, Field>} */
+	const res = {};
+	for (const [name, { type, ...field }] of Object.entries(fields)) {
+		if (ignore.has(name)) continue;
+		if (!type) continue;
+		if (typeof type !== "object" && typeof type !== "function") {
+			res[name] = {
+				type,
+				array: field.array,
+				nullable: field.nullable,
+				default: field.default,
+				scale: field.scale,
+				primary: field.primary,
+				uncreatable: Boolean(field.uncreatable || field.updating || field.creating || field.fixedValue),
+				immutable: Boolean(field.primary || field.immutable || field.updating || field.creating || field.fixedValue),
+				layoutOrder: field.layoutOrder,
+				label: field.label,
+				description: field.description,
+				placeholder: field.placeholder,
+				step: field.step,
+				max: field.max,
+				min: field.min,
+				readonly: field.readonly,
+				required: field.required,
+				clearable: field.clearable,
+				disabled: field.disabled,
+				group: field.group,
+				renderer: field.renderer,
+				scripts: field.scripts,
+				layout: field.layout,
+				model: field.model,
+				sort: field.sort
+			};
+			continue;
+		}
+		const fields = type.fields;
+		if (!fields) continue;
+		const subFields = toSubDocumentFields(fields, new Set(Object.keys(field.constraints || {})));
+		if (!subFields) continue;
+		res[name] = {
+			type: subFields,
+			array: field.array,
+			default: field.default,
+			uncreatable: Boolean(field.uncreatable),
+			immutable: Boolean(field.immutable),
+			layoutOrder: field.layoutOrder,
+			label: field.label,
+			description: field.description,
+			placeholder: field.placeholder,
+			readonly: field.readonly,
+			required: field.required,
+			clearable: field.clearable,
+			disabled: field.disabled,
+			group: field.group,
+			renderer: field.renderer,
+			scripts: field.scripts,
+			layout: field.layout
+		};
+	}
+	if (!Object.keys(res).length) return null;
+	return res;
+}
+/**
+* 
+* @param {Record<string, FieldDefine>} fields 
+* @returns {Record<string, Field>}
+*/
+function toDocumentFields(fields) {
+	return toSubDocumentFields(fields, /* @__PURE__ */ new Set()) || {};
+}
+
+//#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);
+/**
+* 
+* @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();
+}
+
+//#endregion
+//#region packages/core/search2where/hook.mjs
+/** @import { MaybePromise, WhereHook } from '../types.mjs' */
+/**
+* 
+* @param {MaybePromise<Where?>} [where] 
+*/
+async function toNot(where) {
+	const w = await where;
+	if (!w) return null;
+	return Where.not(w);
+}
+/**
+* @template T
+* @param {Record<string, T>} map 
+* @param {string} key 
+* @param {() => T} create 
+*/
+function select(map, key, create) {
+	if (Object.hasOwn(map, key)) return map[key];
+	return map[key] = create();
+}
+/**
+* @typedef WhereDefine
+* @property {string} label
+* @property {string} notLabel
+* @property {WhereHook.Value[]} value
+* @property {WhereHook.Value[]} notValue
+* @property {WhereHook.Named[]} named
+* @property {WhereHook.Named[]} notNamed
+* @property {WhereHook.Field[]} field
+* @property {WhereHook.Field[]} notField
+*/
+/**
+* 
+* @returns {WhereDefine}
+*/
+function createWhereDefine() {
+	return {
+		label: "",
+		notLabel: "",
+		value: [],
+		notValue: [],
+		named: [],
+		notNamed: [],
+		field: [],
+		notField: []
+	};
+}
+function getWhere() {
+	/** @type {Record<string, Record<string, WhereDefine>>} */
+	const filterMap = {};
+	/** @type {Record<string, Record<string, WhereDefine>>} */
+	const notFilterMap = {};
+	for (const [, type, fieldWhere] of hooks.get("where").entriesObject()) {
+		if (!fieldWhere || typeof fieldWhere !== "object") continue;
+		const typeFilters = select(filterMap, type, () => ({}));
+		const notTypeFilters = select(notFilterMap, type, () => ({}));
+		for (const [op, filters] of Object.entries(fieldWhere)) for (const filter of [filters].flat()) {
+			if (!filter || typeof filter !== "object") continue;
+			let { label, notLabel, not, value, notValue, named, notNamed, field, notField } = filter;
+			if (not) {
+				if (typeof value === "function" && true) notValue = (...p) => toNot(value(...p));
+				if (typeof field === "function" && true) notField = (...p) => toNot(field(...p));
+				if (typeof named === "function" && true) notNamed = (...p) => toNot(named(...p));
+			}
+			const typeFilter = select(typeFilters, op, createWhereDefine);
+			if (label && typeof label === "string") typeFilter.label = label;
+			if (notLabel && typeof notLabel === "string") typeFilter.notLabel = notLabel;
+			if (typeof value === "function") typeFilter.value.push(value);
+			if (typeof notValue === "function") typeFilter.notValue.push(notValue);
+			if (typeof named === "function") typeFilter.named.push(named);
+			if (typeof notNamed === "function") typeFilter.notNamed.push(notNamed);
+			if (typeof field === "function") typeFilter.field.push(field);
+			if (typeof notField === "function") typeFilter.notField.push(notField);
+			const notOp = typeof not === "string" && not || "";
+			if (!notOp) continue;
+			const notTypeFilter = select(notTypeFilters, notOp, createWhereDefine);
+			if (label && typeof label === "string") notTypeFilter.notLabel = label;
+			if (notLabel && typeof notLabel === "string") notTypeFilter.label = notLabel;
+			if (typeof value === "function") notTypeFilter.notValue.push(value);
+			if (typeof notValue === "function") notTypeFilter.value.push(notValue);
+			if (typeof named === "function") notTypeFilter.notNamed.push(named);
+			if (typeof notNamed === "function") notTypeFilter.named.push(notNamed);
+			if (typeof field === "function") notTypeFilter.notField.push(field);
+			if (typeof notField === "function") notTypeFilter.field.push(notField);
+		}
+	}
+	for (const type of Object.keys({
+		...filterMap,
+		...notFilterMap
+	})) {
+		let typeFilters = Object.hasOwn(filterMap, type) && filterMap[type] || null;
+		let notTypeFilters = Object.hasOwn(notFilterMap, type) && notFilterMap[type] || null;
+		if (!typeFilters && notTypeFilters) {
+			typeFilters = notTypeFilters;
+			filterMap[type] = typeFilters;
+		}
+		if (!typeFilters) continue;
+		for (const op of Object.keys({
+			...typeFilters,
+			...notTypeFilters
+		})) {
+			let opFilters = Object.hasOwn(typeFilters, op) && typeFilters[op] || null;
+			let notOpFilters = notTypeFilters && Object.hasOwn(notTypeFilters, op) && notTypeFilters[op] || null;
+			if (!opFilters && notOpFilters) {
+				opFilters = notOpFilters;
+				typeFilters[type] = opFilters;
+			}
+			if (!opFilters) continue;
+			if (!opFilters.label) opFilters.label = notOpFilters?.label || op;
+			if (!opFilters.notLabel) opFilters.notLabel = notOpFilters?.notLabel || `!${op}`;
+			if (!notOpFilters) continue;
+			for (const fn of notOpFilters.value) opFilters.value.push(fn);
+			for (const fn of notOpFilters.notValue) opFilters.notValue.push(fn);
+			for (const fn of notOpFilters.named) opFilters.named.push(fn);
+			for (const fn of notOpFilters.notNamed) opFilters.notNamed.push(fn);
+			for (const fn of notOpFilters.field) opFilters.field.push(fn);
+			for (const fn of notOpFilters.notField) opFilters.notField.push(fn);
+		}
+	}
+	return filterMap;
+}
+/**
+* 
+* @param {ReturnType<typeof getWhere>} filterMap 
+*/
+function toWhereList(filterMap) {
+	/** @type {{type: string; operator: string; label: string; notLabel: string; value: boolean; notValue: boolean; named: boolean; notNamed: boolean; field: boolean; notField: boolean}[]} */
+	const list = [];
+	for (const [type, filters] of Object.entries(filterMap)) for (const [operator, filter] of Object.entries(filters)) list.push({
+		type,
+		operator,
+		label: filter.label,
+		notLabel: filter.notLabel,
+		value: Boolean(filter.value.length),
+		notValue: Boolean(filter.notValue.length),
+		named: Boolean(filter.named.length),
+		notNamed: Boolean(filter.notNamed.length),
+		field: Boolean(filter.field.length),
+		notField: Boolean(filter.notField.length)
+	});
+}
+let allWhere = getWhere();
+let whereList = toWhereList(allWhere);
+hooks.listen(() => {
+	allWhere = getWhere();
+	whereList = toWhereList(allWhere);
+});
+
+//#endregion
+//#region packages/core/search2where/toWhere.mjs
+/** @import { FieldDefine } from '@yongdall/model' */
+/** @import { MaybePromise } from '../types.mjs' */
+/**
+* @typedef {object} WhereParam.Value
+* @property {'value'} type
+* @property {FieldDefine} define
+* @property {string} name
+* @property {string?} operator
+* @property {boolean} not
+* @property {string | RecursiveArray<string> | null} value
+*/
+/**
+* @typedef {object} WhereParam.Field
+* @property {'field'} type
+* @property {FieldDefine} define
+* @property {string} name
+* @property {FieldDefine} fieldDefine
+* @property {string} field
+* @property {string?} operator
+* @property {boolean} not
+*/
+/**
+* @typedef {WhereParam.Value | WhereParam.Field} WhereParam
+*/
+/**
+* 
+* @param {Record<string, FieldDefine>} fields 
+* @param {string[]} path 
+* @param {Search.Match | Search.Children} and
+* @returns {Generator<WhereParam, Where?, Where?>}
+*/
+function* runItemWhere(fields, path, and) {
+	const name = path.shift();
+	if (!name) return null;
+	const define = Object.hasOwn(fields, name) && fields[name];
+	if (!define) return null;
+	const type = define.type;
+	if (!type) return null;
+	if (path.length) {
+		if (typeof type !== "object") return null;
+		if (!type.table) return null;
+		return null;
+	}
+	if (and.length === 2) {
+		if (typeof type !== "object") return null;
+		if (!type.table) return null;
+		return null;
+	}
+	if (typeof type !== "string" && (typeof type !== "object" || type.table)) return null;
+	const [, value, operator, sign] = and;
+	if (operator === null) return yield {
+		type: "value",
+		define,
+		name: define.column || name,
+		value: null,
+		operator,
+		not: Boolean(sign)
+	};
+	if (!value || typeof value !== "object" || Array.isArray(value)) return yield {
+		type: "value",
+		define,
+		name: define.column || name,
+		value,
+		operator,
+		not: Boolean(sign)
+	};
+	const { field, table, value: rValue } = value;
+	if (rValue) return yield {
+		type: "value",
+		define,
+		name: define.column || name,
+		value: rValue,
+		operator,
+		not: Boolean(sign)
+	};
+	if (field) {
+		if (table) return null;
+		const fieldDefine = Object.hasOwn(fields, name) && fields[field];
+		if (!fieldDefine) return null;
+		const type = fieldDefine.type;
+		if (!type) return null;
+		if (typeof type !== "string" && (typeof type !== "object" || type.table)) return null;
+		return yield {
+			type: "field",
+			define,
+			name: define.column || name,
+			field: fieldDefine.column || field,
+			fieldDefine,
+			operator,
+			not: Boolean(sign)
+		};
+	}
+	return null;
+}
+/**
+* 
+* @param {Record<string, FieldDefine>} fields 
+* @param {Search.Match | Search.Children} and
+* @returns {Generator<WhereParam, Where?, Where?>}
+*/
+function* toItemWhere(fields, and) {
+	const path = and[0];
+	if (path.find((v) => Array.isArray(v) && v.length)) return null;
+	return yield* runItemWhere(fields, path.map((v) => typeof v === "string" ? v : v[0]), and);
+}
+/**
+* 
+* @param {Record<string, FieldDefine>} fields 
+* @param {Search.OrList} or
+* @returns {Generator<WhereParam, Where?, Where?>}
+*/
+function* toOrWhere(fields, or) {
+	/** @type {Where?} */
+	let where = null;
+	for (const item of or) if (Array.isArray(item)) {
+		const w = yield* toItemWhere(fields, item);
+		if (w) where = (where || new Where()).or(w);
+	} else {
+		const w = yield* toWhere(fields, item.and, item.or);
+		if (w) where = (where || new Where()).or(w);
+	}
+	return where;
+}
+/**
+* 
+* @param {Record<string, FieldDefine>} fields 
+* @param {Search.AndList} [and] 
+* @param {...Search.OrList | null | undefined} orList
+* @returns {Generator<WhereParam, Where?, Where?>}
+*/
+function* toWhere(fields, and, ...orList) {
+	/** @type {Where?} */
+	let where = null;
+	if (and) for (const item of and) {
+		const w = yield* toItemWhere(fields, item);
+		if (w) where = (where || new Where()).and(w);
+	}
+	for (const or of orList) {
+		if (!or) continue;
+		const w = yield* toOrWhere(fields, or);
+		if (w) where = (where || new Where()).and(w);
+	}
+	return where;
+}
+
+//#endregion
+//#region packages/core/search2where/index.mjs
+/** @import { RecursiveArray } from '@yongdall/common' */
+/** @import { FieldDefine } from '@yongdall/model' */
+/** @import { MaybePromise } from '../types.mjs' */
+/** @import { WhereParam } from './toWhere.mjs' */
+/**
+* 
+* @param {string | {component: string; [k: string]: any} | (string | {component: string; [k: string]: any})[]} [def] 
+* @returns {Iterable<string>}
+*/
+function* getRenderer(def) {
+	if (!def) return;
+	for (const s of Array.isArray(def) ? def : [def]) {
+		if (!s) continue;
+		if (typeof s === "string") {
+			yield s;
+			continue;
+		}
+		if (typeof s !== "object") continue;
+		const component = s.component;
+		if (!component || typeof component !== "string") continue;
+		yield component;
+	}
+}
+/**
+* 
+* @param {FieldDefine} field 
+* @returns {Iterable<string>}
+*/
+function* getKey(field) {
+	const type = field.type;
+	const renderers = field.renderer;
+	const array = field.array ? "[]" : "";
+	if (typeof type === "object") return;
+	if (!type) {
+		for (const renderer of getRenderer(renderers)) {
+			yield `:${renderer}${array}`;
+			yield `${renderer}${array}`;
+		}
+		yield `${array}`;
+		return;
+	}
+	for (const renderer of getRenderer(renderers)) {
+		yield `${type}:${renderer}${array}`;
+		yield `${renderer}${array}`;
+	}
+	yield `${type}${array}`;
+	yield `${array}`;
+}
+/**
+* 
+* @param {WhereParam} param 
+*/
+async function execWhere(param) {
+	const operator = param.operator;
+	if (operator === null) return Where.and(param.name, "=", null, param.not);
+	for (const k of getKey(param.define)) {
+		const typeWhere = Object.hasOwn(allWhere, k) && allWhere[k];
+		if (!typeWhere) continue;
+		const op = Object.hasOwn(typeWhere, operator) && typeWhere[operator];
+		if (!op) continue;
+		if (param.type === "value") {
+			for (const fn of param.not ? op.notValue : op.value) {
+				const w = await fn(param.name, param.value, param.define);
+				if (w) return w;
+			}
+			continue;
+		}
+		if (param.type === "field") {
+			for (const fn of param.not ? op.notField : op.field) {
+				const w = await fn(param.name, param.field, param.define, param.fieldDefine);
+				if (w) return w;
+			}
+			continue;
+		}
+	}
+	if (param.type === "field") for (const k of getKey(param.fieldDefine)) {
+		const typeWhere = Object.hasOwn(allWhere, k) && allWhere[k];
+		if (!typeWhere) continue;
+		const op = Object.hasOwn(typeWhere, operator) && typeWhere[operator];
+		if (!op) continue;
+		for (const fn of param.not ? op.notField : op.field) {
+			const w = await fn(param.field, param.name, param.fieldDefine, param.define);
+			if (w) return w;
+		}
+	}
+	return null;
+}
+/**
+* 
+* @param {Record<string, FieldDefine>} fields 
+* @param {Search.AndList} [and] 
+* @param {Search.OrList} [or] 
+* @param {Search.OrList} [or2] 
+* @returns {Promise<Where?>}
+*/
+async function search2where(fields, and, or, or2) {
+	return Search.asyncRunGenerator(toWhere(fields, and, or, or2), execWhere, null);
+}
+
+//#endregion
+//#region packages/core/index.mjs
+/**
+* 
+* @param {Partial<Omit<Tenant, 'id'>>} tenant 
+* @param {object} boot 
+* @param {Record<string, Partial<Hooks>>} pluginHooks 
+* @returns 
+*/
+function initSystem(tenant, boot, pluginHooks) {
+	initConfig(tenant, 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, hooks, initConfig, isSingleUser, loadPluginUser, loadUser, loadUserOrganizationAllPermissions, loadUserOrganizationPermissions, loadUserPermissions, mainTenant, modelHook, modelLoaders, models, nestedSetTree, search2where, setUser, setUserVerify, testPermissionConstraints, testPermissions, toDocumentFields, useTenant, verifyUser };
+//# sourceMappingURL=index.mjs.map