@eggjs/tegg-controller-plugin 4.0.0-beta.4 → 4.0.0-beta.6

package/README.md

@@ -1,16 +1,28 @@
 # @eggjs/tegg-controller-plugin
 
+[![NPM version][npm-image]][npm-url]
+[![Known Vulnerabilities][snyk-image]][snyk-url]
+[![npm download][download-image]][download-url]
+[![Node.js Version](https://img.shields.io/node/v/@eggjs/tegg-controller-plugin.svg?style=flat)](https://nodejs.org/en/download/)
+
+[npm-image]: https://img.shields.io/npm/v/@eggjs/tegg-controller-plugin.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@eggjs/tegg-controller-plugin
+[snyk-image]: https://snyk.io/test/npm/@eggjs/tegg-controller-plugin/badge.svg?style=flat-square
+[snyk-url]: https://snyk.io/test/npm/@eggjs/tegg-controller-plugin
+[download-image]: https://img.shields.io/npm/dm/@eggjs/tegg-controller-plugin.svg?style=flat-square
+[download-url]: https://npmjs.org/package/@eggjs/tegg-controller-plugin
+
 使用注解的方式来开发 egg 中的 Controller
 
 ## Install
 
 ```shell
 # tegg 注解
-npm i --save @eggjs/tegg
+npm i --save @eggjs/tegg@beta
 # tegg 插件
-npm i --save @eggjs/tegg-plugin
+npm i --save @eggjs/tegg-plugin@beta
 # tegg controller 插件
-npm i --save @eggjs/tegg-controller-plugin
+npm i --save @eggjs/tegg-controller-plugin@beta
 ```
 
 ## Prepare

package/dist/app/middleware/tegg_root_proto.d.ts

@@ -0,0 +1,6 @@
+import { MiddlewareFunc } from "egg";
+
+//#region src/app/middleware/tegg_root_proto.d.ts
+declare const _default: () => MiddlewareFunc;
+//#endregion
+export { _default as default };

package/dist/app/middleware/tegg_root_proto.js

@@ -0,0 +1,12 @@
+import { ROOT_PROTO } from "@eggjs/egg-module-common";
+
+//#region src/app/middleware/tegg_root_proto.ts
+var tegg_root_proto_default = () => {
+	return async function teggRootProto(ctx, next) {
+		ctx[ROOT_PROTO] = ctx.app.rootProtoManager.getRootProto(ctx);
+		return next();
+	};
+};
+
+//#endregion
+export { tegg_root_proto_default as default };

package/dist/app.d.ts

@@ -0,0 +1,27 @@
+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
+export { ControllerAppBootHook as default };

package/dist/app.js

@@ -0,0 +1,67 @@
+import { CONTROLLER_LOAD_UNIT, ControllerLoadUnit } from "./lib/ControllerLoadUnit.js";
+import { RootProtoManager } from "./lib/RootProtoManager.js";
+import { ControllerRegisterFactory } from "./lib/ControllerRegisterFactory.js";
+import { ControllerMetadataManager } from "./lib/ControllerMetadataManager.js";
+import { AppLoadUnitControllerHook } from "./lib/AppLoadUnitControllerHook.js";
+import { HTTPControllerRegister } from "./lib/impl/http/HTTPControllerRegister.js";
+import { ControllerLoadUnitHandler } from "./lib/ControllerLoadUnitHandler.js";
+import { EggControllerPrototypeHook } from "./lib/EggControllerPrototypeHook.js";
+import { EggControllerLoader } from "./lib/EggControllerLoader.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 as default };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/index.js

@@ -0,0 +1,3 @@
+import "./types.js";
+
+export {  };

package/dist/lib/AppLoadUnitControllerHook.d.ts

@@ -0,0 +1,14 @@
+import { RootProtoManager } from "./RootProtoManager.js";
+import { ControllerRegisterFactory } from "./ControllerRegisterFactory.js";
+import { LoadUnit, LoadUnitLifecycleContext } from "@eggjs/tegg-metadata";
+import { LifecycleHook } from "@eggjs/tegg";
+
+//#region src/lib/AppLoadUnitControllerHook.d.ts
+declare class AppLoadUnitControllerHook implements LifecycleHook<LoadUnitLifecycleContext, LoadUnit> {
+  private readonly controllerRegisterFactory;
+  private readonly rootProtoManager;
+  constructor(controllerRegisterFactory: ControllerRegisterFactory, rootProtoManager: RootProtoManager);
+  postCreate(_: LoadUnitLifecycleContext, obj: LoadUnit): Promise<void>;
+}
+//#endregion
+export { AppLoadUnitControllerHook };

package/dist/lib/AppLoadUnitControllerHook.js

@@ -0,0 +1,29 @@
+import "./RootProtoManager.js";
+import "./ControllerRegisterFactory.js";
+import { ControllerMetadataManager } from "./ControllerMetadataManager.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/lib/ControllerLoadUnit.d.ts

@@ -0,0 +1,25 @@
+import { EggPrototype, EggPrototypeCreatorFactory, EggPrototypeFactory, LoadUnit, Loader } from "@eggjs/tegg-metadata";
+import { Id, QualifierInfo } from "@eggjs/tegg";
+
+//#region src/lib/ControllerLoadUnit.d.ts
+declare const CONTROLLER_LOAD_UNIT = "app#controller";
+declare class ControllerLoadUnit implements LoadUnit {
+  private readonly loader;
+  id: Id;
+  readonly name: string;
+  readonly type = "app#controller";
+  readonly unitPath: string;
+  private eggPrototypeFactory;
+  private eggPrototypeCreatorFactory;
+  private protoMap;
+  constructor(name: string, unitPath: string, loader: Loader, eggPrototypeFactory: EggPrototypeFactory, eggPrototypeCreatorFactory: typeof EggPrototypeCreatorFactory);
+  init(): Promise<void>;
+  containPrototype(proto: EggPrototype): boolean;
+  getEggPrototype(name: string, qualifiers: QualifierInfo[]): EggPrototype[];
+  registerEggPrototype(proto: EggPrototype): void;
+  deletePrototype(proto: EggPrototype): void;
+  destroy(): Promise<void>;
+  iterateEggPrototype(): IterableIterator<EggPrototype>;
+}
+//#endregion
+export { CONTROLLER_LOAD_UNIT, ControllerLoadUnit };

package/dist/lib/ControllerLoadUnit.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/lib/ControllerLoadUnitHandler.d.ts

@@ -0,0 +1,16 @@
+import { LoadUnit } from "@eggjs/tegg-metadata";
+import { LoadUnitInstance } from "@eggjs/tegg-runtime";
+import { Application } from "egg";
+import { Base } from "sdk-base";
+
+//#region src/lib/ControllerLoadUnitHandler.d.ts
+declare class ControllerLoadUnitHandler extends Base {
+  private readonly app;
+  controllerLoadUnit: LoadUnit;
+  controllerLoadUnitInstance: LoadUnitInstance;
+  constructor(app: Application);
+  _init(): Promise<void>;
+  destroy(): Promise<void>;
+}
+//#endregion
+export { ControllerLoadUnitHandler };

package/dist/lib/ControllerLoadUnitHandler.js

@@ -0,0 +1,29 @@
+import { CONTROLLER_LOAD_UNIT } from "./ControllerLoadUnit.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/lib/ControllerLoadUnitInstance.d.ts

@@ -0,0 +1,21 @@
+import { EggPrototype, LoadUnit } from "@eggjs/tegg-metadata";
+import { EggObjectName } from "@eggjs/tegg";
+import { EggObject, LoadUnitInstance, LoadUnitInstanceLifecycleContext, LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
+
+//#region src/lib/ControllerLoadUnitInstance.d.ts
+declare class ControllerLoadUnitInstance implements LoadUnitInstance {
+  readonly loadUnit: LoadUnit;
+  readonly id: string;
+  readonly name: string;
+  private protoToCreateMap;
+  private loadUnitInstanceLifecycleUtil;
+  constructor(loadUnit: LoadUnit, loadUnitInstanceLifecycleUtil: typeof LoadUnitInstanceLifecycleUtil);
+  iterateProtoToCreate(): IterableIterator<[EggObjectName, EggPrototype]>;
+  addProtoToCreate(): void;
+  deleteProtoToCreate(): void;
+  init(ctx: LoadUnitInstanceLifecycleContext): Promise<void>;
+  getOrCreateEggObject(): Promise<EggObject>;
+  getEggObject(): EggObject;
+}
+//#endregion
+export { ControllerLoadUnitInstance };

package/dist/lib/ControllerLoadUnitInstance.js

@@ -0,0 +1,40 @@
+import "@eggjs/tegg-metadata";
+import { IdenticalUtil } from "@eggjs/tegg";
+import { LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
+
+//#region src/lib/ControllerLoadUnitInstance.ts
+var ControllerLoadUnitInstance = class {
+	loadUnit;
+	id;
+	name;
+	protoToCreateMap = /* @__PURE__ */ new Map();
+	loadUnitInstanceLifecycleUtil;
+	constructor(loadUnit, loadUnitInstanceLifecycleUtil) {
+		this.loadUnit = loadUnit;
+		this.name = loadUnit.name;
+		this.id = IdenticalUtil.createLoadUnitInstanceId(loadUnit.id);
+		this.loadUnitInstanceLifecycleUtil = loadUnitInstanceLifecycleUtil;
+	}
+	iterateProtoToCreate() {
+		return this.protoToCreateMap.entries();
+	}
+	addProtoToCreate() {
+		throw new Error("controller load unit not allow have singleton proto");
+	}
+	deleteProtoToCreate() {
+		throw new Error("controller load unit not allow have singleton proto");
+	}
+	async init(ctx) {
+		await this.loadUnitInstanceLifecycleUtil.objectPreCreate(ctx, this);
+		await this.loadUnitInstanceLifecycleUtil.objectPostCreate(ctx, this);
+	}
+	async getOrCreateEggObject() {
+		throw new Error("controller load unit not allow have singleton proto");
+	}
+	getEggObject() {
+		throw new Error("controller load unit not allow have singleton proto");
+	}
+};
+
+//#endregion
+export { ControllerLoadUnitInstance };

package/dist/lib/ControllerMetadataManager.d.ts

@@ -0,0 +1,12 @@
+import { ControllerMetadata } from "@eggjs/tegg";
+
+//#region src/lib/ControllerMetadataManager.d.ts
+declare class ControllerMetadataManager {
+  private readonly controllers;
+  static instance: ControllerMetadataManager;
+  constructor();
+  addController(metadata: ControllerMetadata): void;
+  clear(): void;
+}
+//#endregion
+export { ControllerMetadataManager };

package/dist/lib/ControllerMetadataManager.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/lib/ControllerRegister.d.ts

@@ -0,0 +1,9 @@
+import { RootProtoManager } from "./RootProtoManager.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/lib/ControllerRegister.js

@@ -0,0 +1,4 @@
+import "./RootProtoManager.js";
+import "@eggjs/tegg-metadata";
+
+export {  };

package/dist/lib/ControllerRegisterFactory.d.ts

@@ -0,0 +1,16 @@
+import { ControllerRegister } from "./ControllerRegister.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/lib/ControllerRegisterFactory.js

@@ -0,0 +1,24 @@
+import "./ControllerRegister.js";
+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/lib/EggControllerLoader.d.ts

@@ -0,0 +1,11 @@
+import { EggProtoImplClass } from "@eggjs/tegg";
+import { Loader } from "@eggjs/tegg-types";
+
+//#region src/lib/EggControllerLoader.d.ts
+declare class EggControllerLoader implements Loader {
+  private readonly controllerDir;
+  constructor(controllerDir: string);
+  load(): Promise<EggProtoImplClass[]>;
+}
+//#endregion
+export { EggControllerLoader };

package/dist/lib/EggControllerLoader.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/lib/EggControllerPrototypeHook.d.ts

@@ -0,0 +1,9 @@
+import { EggPrototype, EggPrototypeLifecycleContext } from "@eggjs/tegg-metadata";
+import { LifecycleHook } from "@eggjs/tegg";
+
+//#region src/lib/EggControllerPrototypeHook.d.ts
+declare class EggControllerPrototypeHook implements LifecycleHook<EggPrototypeLifecycleContext, EggPrototype> {
+  postCreate(ctx: EggPrototypeLifecycleContext): Promise<void>;
+}
+//#endregion
+export { EggControllerPrototypeHook };

package/dist/lib/EggControllerPrototypeHook.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/lib/RootProtoManager.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/lib/RootProtoManager.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/lib/errors.d.ts

@@ -0,0 +1,9 @@
+import { TeggError } from "@eggjs/tegg-metadata";
+
+//#region src/lib/errors.d.ts
+/** 路由冲突错误 */
+declare class RouterConflictError extends TeggError {
+  constructor(msg: string);
+}
+//#endregion
+export { RouterConflictError };

package/dist/lib/errors.js

@@ -0,0 +1,16 @@
+import { TeggError } from "@eggjs/tegg-metadata";
+
+//#region src/lib/errors.ts
+var ErrorCodes = /* @__PURE__ */ function(ErrorCodes$1) {
+	ErrorCodes$1["ROUTER_CONFLICT"] = "ROUTER_CONFLICT";
+	return ErrorCodes$1;
+}(ErrorCodes || {});
+/** 路由冲突错误 */
+var RouterConflictError = class extends TeggError {
+	constructor(msg) {
+		super(msg, ErrorCodes.ROUTER_CONFLICT);
+	}
+};
+
+//#endregion
+export { RouterConflictError };

package/dist/lib/impl/http/Acl.d.ts

@@ -0,0 +1,6 @@
+import { EggContext, HTTPControllerMeta, HTTPMethodMeta, Next } from "@eggjs/tegg";
+
+//#region src/lib/impl/http/Acl.d.ts
+declare function aclMiddlewareFactory(controllerMeta: HTTPControllerMeta, methodMeta: HTTPMethodMeta): (ctx: EggContext, next: Next) => Promise<void>;
+//#endregion
+export { aclMiddlewareFactory };