@eggjs/tegg-controller-plugin 4.0.0-beta.7 → 4.0.0-beta.8

package/dist/Acl-BF8dxD8f.js

@@ -0,0 +1,29 @@
+import "@eggjs/tegg";
+
+//#region src/lib/impl/http/Acl.ts
+function aclMiddlewareFactory(controllerMeta, methodMeta) {
+	if (!controllerMeta.hasMethodAcl(methodMeta)) return;
+	const code = controllerMeta.getMethodAcl(methodMeta);
+	return async function aclMiddleware(ctx, next) {
+		try {
+			await ctx.acl(code);
+		} catch (e) {
+			const { redirectUrl, status } = e.data || {};
+			if (!redirectUrl) throw e;
+			if (ctx.acceptJSON) {
+				ctx.body = {
+					target: redirectUrl,
+					stat: "deny"
+				};
+				return;
+			}
+			if (status) ctx.realStatus = status;
+			ctx.redirect(redirectUrl);
+			return;
+		}
+		return next();
+	};
+}
+
+//#endregion
+export { aclMiddlewareFactory };

package/dist/AppLoadUnitControllerHook-C3F2NtiE.js

@@ -0,0 +1,27 @@
+import { ControllerMetadataManager } from "./ControllerMetadataManager-CC5nmTlv.js";
+import "@eggjs/tegg-metadata";
+import { CONTROLLER_META_DATA } from "@eggjs/tegg";
+
+//#region src/lib/AppLoadUnitControllerHook.ts
+var AppLoadUnitControllerHook = class {
+	controllerRegisterFactory;
+	rootProtoManager;
+	constructor(controllerRegisterFactory, rootProtoManager) {
+		this.controllerRegisterFactory = controllerRegisterFactory;
+		this.rootProtoManager = rootProtoManager;
+	}
+	async postCreate(_, obj) {
+		const iterator = obj.iterateEggPrototype();
+		for (const proto of iterator) {
+			const metadata = proto.getMetaData(CONTROLLER_META_DATA);
+			if (!metadata) continue;
+			const register = this.controllerRegisterFactory.getControllerRegister(proto, metadata);
+			if (!register) throw new Error(`not find controller implement for ${String(proto.name)} which type is ${metadata.type}`);
+			ControllerMetadataManager.instance.addController(metadata);
+			await register.register(this.rootProtoManager, obj);
+		}
+	}
+};
+
+//#endregion
+export { AppLoadUnitControllerHook };

package/dist/ControllerLoadUnit-DWgcQuC0.js

@@ -0,0 +1,63 @@
+import { EggPrototypeFactory } from "@eggjs/tegg-metadata";
+import { IdenticalUtil } from "@eggjs/tegg";
+import { MapUtil } from "@eggjs/tegg-common-util";
+
+//#region src/lib/ControllerLoadUnit.ts
+const CONTROLLER_LOAD_UNIT = "app#controller";
+var ControllerLoadUnit = class {
+	loader;
+	id;
+	name;
+	type = CONTROLLER_LOAD_UNIT;
+	unitPath;
+	eggPrototypeFactory;
+	eggPrototypeCreatorFactory;
+	protoMap = /* @__PURE__ */ new Map();
+	constructor(name, unitPath, loader, eggPrototypeFactory, eggPrototypeCreatorFactory) {
+		this.id = IdenticalUtil.createLoadUnitId(name);
+		this.name = name;
+		this.unitPath = unitPath;
+		this.loader = loader;
+		this.eggPrototypeFactory = eggPrototypeFactory;
+		this.eggPrototypeCreatorFactory = eggPrototypeCreatorFactory;
+	}
+	async init() {
+		const clazzList = await this.loader.load();
+		for (const clazz of clazzList) {
+			const protos = await this.eggPrototypeCreatorFactory.createProto(clazz, this);
+			for (const proto of protos) this.eggPrototypeFactory.registerPrototype(proto, this);
+		}
+	}
+	containPrototype(proto) {
+		return !!this.protoMap.get(proto.name)?.find((t) => t === proto);
+	}
+	getEggPrototype(name, qualifiers) {
+		return this.protoMap.get(name)?.filter((proto) => proto.verifyQualifiers(qualifiers)) || [];
+	}
+	registerEggPrototype(proto) {
+		MapUtil.getOrStore(this.protoMap, proto.name, []).push(proto);
+	}
+	deletePrototype(proto) {
+		const protos = this.protoMap.get(proto.name);
+		if (protos) {
+			const index = protos.indexOf(proto);
+			if (index !== -1) protos.splice(index, 1);
+		}
+	}
+	async destroy() {
+		for (const namedProtos of this.protoMap.values()) {
+			const protos = namedProtos.slice();
+			for (const proto of protos) EggPrototypeFactory.instance.deletePrototype(proto, this);
+		}
+		this.protoMap.clear();
+	}
+	iterateEggPrototype() {
+		return Array.from(this.protoMap.values()).reduce((p, c) => {
+			p = p.concat(c);
+			return p;
+		}, []).values();
+	}
+};
+
+//#endregion
+export { CONTROLLER_LOAD_UNIT, ControllerLoadUnit };

package/dist/ControllerLoadUnitHandler-BiPlOVSN.js

@@ -0,0 +1,29 @@
+import { CONTROLLER_LOAD_UNIT } from "./ControllerLoadUnit-DWgcQuC0.js";
+import "@eggjs/tegg-metadata";
+import "@eggjs/tegg-runtime";
+import path from "node:path";
+import { Base } from "sdk-base";
+
+//#region src/lib/ControllerLoadUnitHandler.ts
+var ControllerLoadUnitHandler = class extends Base {
+	app;
+	controllerLoadUnit;
+	controllerLoadUnitInstance;
+	constructor(app) {
+		super({ initMethod: "_init" });
+		this.app = app;
+	}
+	async _init() {
+		const controllerDir = path.join(this.app.config.baseDir, "app/controller");
+		const loader = this.app.loaderFactory.createLoader(controllerDir, CONTROLLER_LOAD_UNIT);
+		this.controllerLoadUnit = await this.app.loadUnitFactory.createLoadUnit(controllerDir, CONTROLLER_LOAD_UNIT, loader);
+		this.controllerLoadUnitInstance = await this.app.loadUnitInstanceFactory.createLoadUnitInstance(this.controllerLoadUnit);
+	}
+	async destroy() {
+		if (this.controllerLoadUnit) await this.app.loadUnitFactory.destroyLoadUnit(this.controllerLoadUnit);
+		if (this.controllerLoadUnitInstance) await this.app.loadUnitInstanceFactory.destroyLoadUnitInstance(this.controllerLoadUnitInstance);
+	}
+};
+
+//#endregion
+export { ControllerLoadUnitHandler };

package/dist/ControllerMetadataManager-CC5nmTlv.js

@@ -0,0 +1,23 @@
+import "@eggjs/tegg";
+import { MapUtil } from "@eggjs/tegg-common-util";
+
+//#region src/lib/ControllerMetadataManager.ts
+var ControllerMetadataManager = class ControllerMetadataManager {
+	controllers = /* @__PURE__ */ new Map();
+	static instance = new ControllerMetadataManager();
+	constructor() {
+		this.controllers = /* @__PURE__ */ new Map();
+	}
+	addController(metadata) {
+		const typeControllers = MapUtil.getOrStore(this.controllers, metadata.type, []);
+		if (typeControllers.filter((c) => c.controllerName === metadata.controllerName).length) throw new Error(`duplicate controller name ${metadata.controllerName}`);
+		if (typeControllers.filter((c) => c.protoName === metadata.protoName).length) throw new Error(`duplicate proto name ${String(metadata.protoName)}`);
+		typeControllers.push(metadata);
+	}
+	clear() {
+		this.controllers.clear();
+	}
+};
+
+//#endregion
+export { ControllerMetadataManager };

package/dist/ControllerRegister-DDwsWz5F.d.ts

@@ -0,0 +1,9 @@
+import { RootProtoManager } from "./RootProtoManager-DkqD47oc.js";
+import { LoadUnit } from "@eggjs/tegg-metadata";
+
+//#region src/lib/ControllerRegister.d.ts
+interface ControllerRegister {
+  register(rootProtoManager: RootProtoManager, loadUnit?: LoadUnit): Promise<void>;
+}
+//#endregion
+export { ControllerRegister };

package/dist/ControllerRegister-DPqM08MF.js

@@ -0,0 +1,3 @@
+import "@eggjs/tegg-metadata";
+
+export {  };

package/dist/ControllerRegisterFactory-Bz7bulBg.js

@@ -0,0 +1,23 @@
+import "@eggjs/tegg-metadata";
+import "@eggjs/tegg";
+
+//#region src/lib/ControllerRegisterFactory.ts
+var ControllerRegisterFactory = class {
+	app;
+	registerCreatorMap;
+	constructor(app) {
+		this.app = app;
+		this.registerCreatorMap = /* @__PURE__ */ new Map();
+	}
+	registerControllerRegister(type, creator) {
+		this.registerCreatorMap.set(type, creator);
+	}
+	getControllerRegister(proto, metadata) {
+		const creator = this.registerCreatorMap.get(metadata.type);
+		if (!creator) return;
+		return creator(proto, metadata, this.app);
+	}
+};
+
+//#endregion
+export { ControllerRegisterFactory };

package/dist/ControllerRegisterFactory-DCPVkM4E.d.ts

@@ -0,0 +1,16 @@
+import { ControllerRegister } from "./ControllerRegister-DDwsWz5F.js";
+import { EggPrototype } from "@eggjs/tegg-metadata";
+import { ControllerMetadata, ControllerTypeLike } from "@eggjs/tegg";
+import { Application } from "egg";
+
+//#region src/lib/ControllerRegisterFactory.d.ts
+type RegisterCreator = (proto: EggPrototype, controllerMeta: ControllerMetadata, app: Application) => ControllerRegister;
+declare class ControllerRegisterFactory {
+  private readonly app;
+  private registerCreatorMap;
+  constructor(app: Application);
+  registerControllerRegister(type: ControllerTypeLike, creator: RegisterCreator): void;
+  getControllerRegister(proto: EggPrototype, metadata: ControllerMetadata): ControllerRegister | undefined;
+}
+//#endregion
+export { ControllerRegisterFactory, RegisterCreator };

package/dist/EggControllerLoader-iohfFKpj.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+import { globby } from "globby";
+import { LoaderUtil } from "@eggjs/tegg-loader";
+
+//#region src/lib/EggControllerLoader.ts
+var EggControllerLoader = class {
+	controllerDir;
+	constructor(controllerDir) {
+		this.controllerDir = controllerDir;
+	}
+	async load() {
+		const filePattern = LoaderUtil.filePattern();
+		let files;
+		try {
+			files = (await globby(filePattern, { cwd: this.controllerDir })).map((file) => path.join(this.controllerDir, file));
+		} catch {
+			files = [];
+		}
+		const protoClassList = [];
+		for (const file of files) {
+			const fileClazzList = await LoaderUtil.loadFile(file);
+			for (const clazz of fileClazzList) protoClassList.push(clazz);
+		}
+		return protoClassList;
+	}
+};
+
+//#endregion
+export { EggControllerLoader };

package/dist/EggControllerPrototypeHook-Djf4Mwvw.js

@@ -0,0 +1,13 @@
+import "@eggjs/tegg-metadata";
+import { ControllerMetaBuilderFactory, ControllerMetadataUtil } from "@eggjs/tegg";
+
+//#region src/lib/EggControllerPrototypeHook.ts
+var EggControllerPrototypeHook = class {
+	async postCreate(ctx) {
+		const metadata = ControllerMetaBuilderFactory.build(ctx.clazz);
+		if (metadata) ControllerMetadataUtil.setControllerMetadata(ctx.clazz, metadata);
+	}
+};
+
+//#endregion
+export { EggControllerPrototypeHook };

package/dist/HTTPControllerRegister-CZQJslUT.js

@@ -0,0 +1,58 @@
+import { HTTPMethodRegister } from "./HTTPMethodRegister-CHHFV-eT.js";
+import "@eggjs/tegg-metadata";
+import { CONTROLLER_META_DATA, ControllerType, HTTPControllerMeta, HTTPMethodMeta } from "@eggjs/tegg";
+import { EggContainerFactory } from "@eggjs/tegg-runtime";
+import assert from "node:assert/strict";
+import { Application, Router } from "egg";
+
+//#region src/lib/impl/http/HTTPControllerRegister.ts
+var HTTPControllerRegister = class HTTPControllerRegister {
+	static instance;
+	router;
+	checkRouters;
+	eggContainerFactory;
+	controllerProtos = [];
+	static create(proto, controllerMeta, app) {
+		assert(controllerMeta.type === ControllerType.HTTP, "controller meta type is not HTTP");
+		if (!HTTPControllerRegister.instance) HTTPControllerRegister.instance = new HTTPControllerRegister(app.router, app.eggContainerFactory);
+		HTTPControllerRegister.instance.controllerProtos.push(proto);
+		return HTTPControllerRegister.instance;
+	}
+	constructor(router, eggContainerFactory) {
+		this.router = router;
+		this.checkRouters = /* @__PURE__ */ new Map();
+		this.checkRouters.set("default", router);
+		this.eggContainerFactory = eggContainerFactory;
+	}
+	register() {
+		return Promise.resolve();
+	}
+	static clean() {
+		if (this.instance) {
+			this.instance.controllerProtos = [];
+			this.instance.checkRouters.clear();
+		}
+		this.instance = void 0;
+	}
+	doRegister(rootProtoManager) {
+		const methodMap = /* @__PURE__ */ new Map();
+		for (const proto of this.controllerProtos) {
+			const metadata = proto.getMetaData(CONTROLLER_META_DATA);
+			for (const method of metadata.methods) methodMap.set(method, proto);
+		}
+		const allMethods = Array.from(methodMap.keys()).sort((a, b) => b.priority - a.priority);
+		for (const method of allMethods) {
+			const controllerProto = methodMap.get(method);
+			const controllerMeta = controllerProto.getMetaData(CONTROLLER_META_DATA);
+			new HTTPMethodRegister(controllerProto, controllerMeta, method, this.router, this.checkRouters, this.eggContainerFactory).checkDuplicate();
+		}
+		for (const method of allMethods) {
+			const controllerProto = methodMap.get(method);
+			const controllerMeta = controllerProto.getMetaData(CONTROLLER_META_DATA);
+			new HTTPMethodRegister(controllerProto, controllerMeta, method, this.router, this.checkRouters, this.eggContainerFactory).register(rootProtoManager);
+		}
+	}
+};
+
+//#endregion
+export { HTTPControllerRegister };

package/dist/HTTPMethodRegister-CHHFV-eT.js

@@ -0,0 +1,138 @@
+import { aclMiddlewareFactory } from "./Acl-BF8dxD8f.js";
+import { HTTPRequest as HTTPRequest$1 } from "./Req-D3i-7606.js";
+import { RouterConflictError } from "./errors-CnXI09lf.js";
+import "@eggjs/tegg-metadata";
+import { HTTPControllerMeta, HTTPCookies, HTTPMethodMeta, HTTPParamType } from "@eggjs/tegg";
+import { EggContainerFactory } from "@eggjs/tegg-runtime";
+import { Context, Router } from "egg";
+import assert from "node:assert";
+import pathToRegexp from "path-to-regexp";
+import { EggRouter } from "@eggjs/router";
+import { FrameworkErrorFormater } from "egg-errors";
+
+//#region src/lib/impl/http/HTTPMethodRegister.ts
+const noop = () => {};
+var HTTPMethodRegister = class {
+	router;
+	checkRouters;
+	controllerMeta;
+	methodMeta;
+	proto;
+	eggContainerFactory;
+	constructor(proto, controllerMeta, methodMeta, router, checkRouters, eggContainerFactory) {
+		this.proto = proto;
+		this.controllerMeta = controllerMeta;
+		this.router = router;
+		this.methodMeta = methodMeta;
+		this.checkRouters = checkRouters;
+		this.eggContainerFactory = eggContainerFactory;
+	}
+	createHandler(methodMeta, host) {
+		const argsLength = methodMeta.paramMap.size;
+		const hasContext = methodMeta.contextParamIndex !== void 0;
+		const contextIndex = methodMeta.contextParamIndex;
+		const methodArgsLength = argsLength + (hasContext ? 1 : 0);
+		const self = this;
+		return async function(ctx, next) {
+			if (host && host !== ctx.host) return await next();
+			const realObj = (await self.eggContainerFactory.getOrCreateEggObject(self.proto, self.proto.name)).obj;
+			const realMethod = realObj[methodMeta.name];
+			const args = Array.from({ length: methodArgsLength });
+			if (hasContext) args[contextIndex] = ctx;
+			for (const [index, param] of methodMeta.paramMap) switch (param.type) {
+				case HTTPParamType.BODY:
+					args[index] = ctx.request.body;
+					break;
+				case HTTPParamType.PARAM: {
+					const pathParam = param;
+					args[index] = ctx.params[pathParam.name];
+					break;
+				}
+				case HTTPParamType.QUERY: {
+					const queryParam = param;
+					args[index] = ctx.query[queryParam.name];
+					break;
+				}
+				case HTTPParamType.QUERIES: {
+					const queryParam = param;
+					args[index] = ctx.queries[queryParam.name];
+					break;
+				}
+				case HTTPParamType.HEADERS:
+					args[index] = ctx.request.headers;
+					break;
+				case HTTPParamType.REQUEST:
+					args[index] = new HTTPRequest$1(ctx);
+					break;
+				case HTTPParamType.COOKIES:
+					args[index] = new HTTPCookies(ctx, []);
+					break;
+				default: assert.fail("never arrive");
+			}
+			const body = await Reflect.apply(realMethod, realObj, args);
+			const explicitStatus = ctx.response._explicitStatus;
+			if (body !== null && body !== void 0 || !explicitStatus) ctx.body = body;
+		};
+	}
+	checkDuplicate() {
+		this.checkDuplicateInRouter(this.router);
+		let hostRouter;
+		(this.controllerMeta.getMethodHosts(this.methodMeta) || []).forEach((h) => {
+			if (h) {
+				hostRouter = this.checkRouters.get(h);
+				if (!hostRouter) {
+					hostRouter = new EggRouter({ sensitive: true }, this.router.app);
+					this.checkRouters.set(h, hostRouter);
+				}
+			}
+			if (hostRouter) {
+				this.checkDuplicateInRouter(hostRouter);
+				this.registerToRouter(hostRouter);
+			}
+		});
+	}
+	registerToRouter(router) {
+		const routerFunc = router[this.methodMeta.method.toLowerCase()];
+		const methodRealPath = this.controllerMeta.getMethodRealPath(this.methodMeta);
+		const methodName = this.controllerMeta.getMethodName(this.methodMeta);
+		Reflect.apply(routerFunc, router, [
+			methodName,
+			methodRealPath,
+			noop
+		]);
+	}
+	checkDuplicateInRouter(router) {
+		const methodRealPath = this.controllerMeta.getMethodRealPath(this.methodMeta);
+		const matched = router.match(methodRealPath, this.methodMeta.method);
+		const methodName = this.controllerMeta.getMethodName(this.methodMeta);
+		if (matched.route) {
+			const [layer] = matched.path;
+			const err = new RouterConflictError(`register http controller ${methodName} failed, ${this.methodMeta.method} ${methodRealPath} is conflict with exists rule ${layer.path}`);
+			throw FrameworkErrorFormater.format(err);
+		}
+	}
+	register(rootProtoManager) {
+		const methodRealPath = this.controllerMeta.getMethodRealPath(this.methodMeta);
+		const methodName = this.controllerMeta.getMethodName(this.methodMeta);
+		const routerFunc = this.router[this.methodMeta.method.toLowerCase()];
+		const methodMiddlewares = this.controllerMeta.getMethodMiddlewares(this.methodMeta);
+		const aclMiddleware = aclMiddlewareFactory(this.controllerMeta, this.methodMeta);
+		if (aclMiddleware) methodMiddlewares.push(aclMiddleware);
+		(this.controllerMeta.getMethodHosts(this.methodMeta) || [void 0]).forEach((h) => {
+			const handler = this.createHandler(this.methodMeta, h);
+			Reflect.apply(routerFunc, this.router, [
+				methodName,
+				methodRealPath,
+				...methodMiddlewares,
+				handler
+			]);
+			const regExp = pathToRegexp(methodRealPath, { sensitive: true });
+			rootProtoManager.registerRootProto(this.methodMeta.method, (ctx) => {
+				if (regExp.test(ctx.path)) return this.proto;
+			}, h || "");
+		});
+	}
+};
+
+//#endregion
+export { HTTPMethodRegister };

package/dist/Req-D3i-7606.js

@@ -0,0 +1,16 @@
+import { HTTPRequest } from "@eggjs/tegg";
+
+//#region src/lib/impl/http/Req.ts
+var HTTPRequest$1 = class extends HTTPRequest {
+	constructor(ctx) {
+		const request = ctx.request;
+		super(request.href, {
+			method: request.method,
+			headers: request.headers,
+			body: ctx.request.rawBody
+		});
+	}
+};
+
+//#endregion
+export { HTTPRequest$1 as HTTPRequest };

package/dist/RootProtoManager-CbLm-PD1.js

@@ -0,0 +1,28 @@
+import "@eggjs/tegg-metadata";
+import "@eggjs/tegg";
+import { MapUtil } from "@eggjs/tegg-common-util";
+
+//#region src/lib/RootProtoManager.ts
+var RootProtoManager = class {
+	protoMap = /* @__PURE__ */ new Map();
+	registerRootProto(method, cb, host) {
+		host = host || "";
+		MapUtil.getOrStore(this.protoMap, method + host, []).push(cb);
+	}
+	getRootProto(ctx) {
+		const hostCbList = this.protoMap.get(ctx.method + ctx.host);
+		if (hostCbList) for (const cb of hostCbList) {
+			const proto = cb(ctx);
+			if (proto) return proto;
+		}
+		const cbList = this.protoMap.get(ctx.method);
+		if (!cbList) return;
+		for (const cb of cbList) {
+			const proto = cb(ctx);
+			if (proto) return proto;
+		}
+	}
+};
+
+//#endregion
+export { RootProtoManager };

package/dist/RootProtoManager-DkqD47oc.d.ts

@@ -0,0 +1,12 @@
+import { EggPrototype } from "@eggjs/tegg-metadata";
+import { EggContext } from "@eggjs/tegg";
+
+//#region src/lib/RootProtoManager.d.ts
+type GetRootProtoCallback = (ctx: EggContext) => EggPrototype | undefined;
+declare class RootProtoManager {
+  protoMap: Map<string, GetRootProtoCallback[]>;
+  registerRootProto(method: string, cb: GetRootProtoCallback, host: string): void;
+  getRootProto(ctx: EggContext): EggPrototype | undefined;
+}
+//#endregion
+export { GetRootProtoCallback, RootProtoManager };

package/dist/app-CZQLJgoQ.d.ts

@@ -0,0 +1,27 @@
+import { RootProtoManager } from "./RootProtoManager-DkqD47oc.js";
+import { ControllerRegisterFactory } from "./ControllerRegisterFactory-DCPVkM4E.js";
+import { ControllerMetaBuilderFactory } from "@eggjs/tegg";
+import { Application, ILifecycleBoot } from "egg";
+
+//#region src/app.d.ts
+declare class ControllerAppBootHook implements ILifecycleBoot {
+  private readonly app;
+  private readonly loadUnitHook;
+  private readonly controllerRegisterFactory;
+  private controllerLoadUnitHandler;
+  private readonly controllerPrototypeHook;
+  constructor(app: Application);
+  configWillLoad(): void;
+  prepareMiddleware(middlewareNames: string[]): string[];
+  didLoad(): Promise<void>;
+  beforeClose(): Promise<void>;
+}
+declare module 'egg' {
+  interface Application {
+    rootProtoManager: RootProtoManager;
+    controllerRegisterFactory: ControllerRegisterFactory;
+    controllerMetaBuilderFactory: typeof ControllerMetaBuilderFactory;
+  }
+}
+//#endregion
+export { ControllerAppBootHook };

package/dist/app-Dq89t2rF.js

@@ -0,0 +1,67 @@
+import { CONTROLLER_LOAD_UNIT, ControllerLoadUnit } from "./ControllerLoadUnit-DWgcQuC0.js";
+import { RootProtoManager } from "./RootProtoManager-CbLm-PD1.js";
+import { ControllerRegisterFactory } from "./ControllerRegisterFactory-Bz7bulBg.js";
+import { ControllerMetadataManager } from "./ControllerMetadataManager-CC5nmTlv.js";
+import { AppLoadUnitControllerHook } from "./AppLoadUnitControllerHook-C3F2NtiE.js";
+import { HTTPControllerRegister } from "./HTTPControllerRegister-CZQJslUT.js";
+import { ControllerLoadUnitHandler } from "./ControllerLoadUnitHandler-BiPlOVSN.js";
+import { EggControllerPrototypeHook } from "./EggControllerPrototypeHook-Djf4Mwvw.js";
+import { EggControllerLoader } from "./EggControllerLoader-iohfFKpj.js";
+import "@eggjs/tegg-metadata";
+import { ControllerMetaBuilderFactory, ControllerType } from "@eggjs/tegg";
+import { ModuleLoadUnitInstance } from "@eggjs/tegg-runtime";
+
+//#region src/app.ts
+var ControllerAppBootHook = class {
+	app;
+	loadUnitHook;
+	controllerRegisterFactory;
+	controllerLoadUnitHandler;
+	controllerPrototypeHook;
+	constructor(app) {
+		this.app = app;
+		this.controllerRegisterFactory = new ControllerRegisterFactory(this.app);
+		this.app.rootProtoManager = new RootProtoManager();
+		this.app.controllerRegisterFactory = this.controllerRegisterFactory;
+		this.app.controllerMetaBuilderFactory = ControllerMetaBuilderFactory;
+		this.loadUnitHook = new AppLoadUnitControllerHook(this.controllerRegisterFactory, this.app.rootProtoManager);
+		this.controllerPrototypeHook = new EggControllerPrototypeHook();
+	}
+	configWillLoad() {
+		this.app.loadUnitLifecycleUtil.registerLifecycle(this.loadUnitHook);
+		this.app.eggPrototypeLifecycleUtil.registerLifecycle(this.controllerPrototypeHook);
+		this.app.loaderFactory.registerLoader(CONTROLLER_LOAD_UNIT, (unitPath) => {
+			return new EggControllerLoader(unitPath);
+		});
+		this.controllerRegisterFactory.registerControllerRegister(ControllerType.HTTP, HTTPControllerRegister.create);
+		this.app.loadUnitFactory.registerLoadUnitCreator(CONTROLLER_LOAD_UNIT, (ctx) => {
+			return new ControllerLoadUnit(`tegg-app-controller:${ctx.unitPath}`, ctx.unitPath, ctx.loader, this.app.eggPrototypeFactory, this.app.eggPrototypeCreatorFactory);
+		});
+		this.app.loadUnitInstanceFactory.registerLoadUnitInstanceClass(CONTROLLER_LOAD_UNIT, (ctx) => {
+			return new ModuleLoadUnitInstance(ctx.loadUnit);
+		});
+		this.prepareMiddleware(this.app.config.coreMiddleware);
+	}
+	prepareMiddleware(middlewareNames) {
+		if (!middlewareNames.includes("teggCtxLifecycleMiddleware")) middlewareNames.unshift("teggCtxLifecycleMiddleware");
+		const index = middlewareNames.indexOf("teggCtxLifecycleMiddleware");
+		middlewareNames.splice(index, 0, "teggRootProto");
+		return middlewareNames;
+	}
+	async didLoad() {
+		await this.app.moduleHandler.ready();
+		this.controllerLoadUnitHandler = new ControllerLoadUnitHandler(this.app);
+		await this.controllerLoadUnitHandler.ready();
+		HTTPControllerRegister.instance?.doRegister(this.app.rootProtoManager);
+	}
+	async beforeClose() {
+		if (this.controllerLoadUnitHandler) await this.controllerLoadUnitHandler.destroy();
+		this.app.loadUnitLifecycleUtil.deleteLifecycle(this.loadUnitHook);
+		this.app.eggPrototypeLifecycleUtil.deleteLifecycle(this.controllerPrototypeHook);
+		ControllerMetadataManager.instance.clear();
+		HTTPControllerRegister.clean();
+	}
+};
+
+//#endregion
+export { ControllerAppBootHook };

package/dist/app.d.ts

@@ -1,27 +1,5 @@
-import { RootProtoManager } from "./lib/RootProtoManager.js";
-import { ControllerRegisterFactory } from "./lib/ControllerRegisterFactory.js";
-import { ControllerMetaBuilderFactory } from "@eggjs/tegg";
-import { Application, ILifecycleBoot } from "egg";
-
-//#region src/app.d.ts
-declare class ControllerAppBootHook implements ILifecycleBoot {
-  private readonly app;
-  private readonly loadUnitHook;
-  private readonly controllerRegisterFactory;
-  private controllerLoadUnitHandler;
-  private readonly controllerPrototypeHook;
-  constructor(app: Application);
-  configWillLoad(): void;
-  prepareMiddleware(middlewareNames: string[]): string[];
-  didLoad(): Promise<void>;
-  beforeClose(): Promise<void>;
-}
-declare module 'egg' {
-  interface Application {
-    rootProtoManager: RootProtoManager;
-    controllerRegisterFactory: ControllerRegisterFactory;
-    controllerMetaBuilderFactory: typeof ControllerMetaBuilderFactory;
-  }
-}
-//#endregion
+import "./RootProtoManager-DkqD47oc.js";
+import "./ControllerRegister-DDwsWz5F.js";
+import "./ControllerRegisterFactory-DCPVkM4E.js";
+import { ControllerAppBootHook } from "./app-CZQLJgoQ.js";
 export { ControllerAppBootHook as default };