@eggjs/core 7.0.2-beta.2 → 7.0.2-beta.22

package/dist/loader/egg_loader.js

@@ -3,6 +3,7 @@ import { sequencify } from "../utils/sequencify.js";
 import { Timing } from "../utils/timing.js";
 import { CaseStyle, FULLPATH, FileLoader } from "./file_loader.js";
 import { ContextLoader } from "./context_loader.js";
+import { ManifestStore } from "./manifest.js";
 import fs from "node:fs";
 import path from "node:path";
 import { debuglog, inspect } from "node:util";
@@ -11,14 +12,35 @@ import assert from "node:assert";
 import { Application, Context, Request, Response } from "@eggjs/koa";
 import { isAsyncFunction, isClass, isGeneratorFunction, isObject, isPromise } from "is-type-of";
 import { extend } from "@eggjs/extend2";
+import { RealLoaderFS } from "@eggjs/loader-fs";
 import { pathMatching } from "@eggjs/path-matching";
+import globby from "globby";
 import { homedir } from "node-homedir";
 import { diff, now } from "performance-ms";
 import { register } from "tsconfig-paths";
-import { exists, getParamNames, readJSON, readJSONSync } from "utility";
+import { getParamNames } from "utility";
 
 //#region src/loader/egg_loader.ts
 const debug = debuglog("egg/core/loader/egg_loader");
+const CONVENTIONAL_MANIFEST_LOADS = [
+	{
+		type: "resolve",
+		path: ["agent"]
+	},
+	{
+		type: "resolve",
+		path: ["app"]
+	},
+	{
+		type: "discover",
+		path: ["app", "extend"],
+		extensionlessResolve: true
+	},
+	{
+		type: "discover",
+		path: ["app", "middleware"]
+	}
+];
 const originalPrototypes = {
 	request: Request.prototype,
 	response: Response.prototype,
@@ -34,7 +56,11 @@ var EggLoader = class {
 	serverEnv;
 	serverScope;
 	appInfo;
+	outDir;
 	dirs;
+	/** Startup manifest — loaded from cache or collecting for generation */
+	manifest;
+	loaderFS;
 	/**
 	* @class
 	* @param {Object} options - options
@@ -46,6 +72,7 @@ var EggLoader = class {
 	*/
 	constructor(options) {
 		this.options = options;
+		this.loaderFS = this.options.loaderFS ?? new RealLoaderFS();
 		assert(fs.existsSync(this.options.baseDir), `${this.options.baseDir} not exists`);
 		assert(this.options.app, "options.app is required");
 		assert(this.options.logger, "options.logger is required");
@@ -55,7 +82,8 @@ var EggLoader = class {
 		* @see {@link AppInfo#pkg}
 		* @since 1.0.0
 		*/
-		this.pkg = readJSONSync(path.join(this.options.baseDir, "package.json"));
+		this.pkg = this.loaderFS.readJSON(path.join(this.options.baseDir, "package.json"));
+		this.outDir = this.#resolveOutDir();
 		if (process.env.EGG_TYPESCRIPT === "true" || this.pkg.egg && this.pkg.egg.typescript) {
 			const tsConfigFile = path.join(this.options.baseDir, "tsconfig.json");
 			if (fs.existsSync(tsConfigFile)) register({ cwd: this.options.baseDir });
@@ -102,6 +130,7 @@ var EggLoader = class {
 		* @since 1.0.0
 		*/
 		this.appInfo = this.getAppInfo();
+		this.manifest = ManifestStore.load(this.options.baseDir, this.serverEnv, this.serverScope) ?? ManifestStore.createCollector(this.options.baseDir);
 	}
 	get app() {
 		return this.options.app;
@@ -382,17 +411,14 @@ var EggLoader = class {
 		let pkg;
 		let eggPluginConfig;
 		const pluginPackage = path.join(plugin.path, "package.json");
-		if (await utils_default.existsPath(pluginPackage)) {
-			pkg = await readJSON(pluginPackage);
+		if (this.loaderFS.exists(pluginPackage)) {
+			pkg = await this.loaderFS.loadFile(pluginPackage);
 			eggPluginConfig = pkg.eggPlugin;
 			if (pkg.version) plugin.version = pkg.version;
 			plugin.path = await this.#formatPluginPathFromPackageJSON(plugin.path, pkg);
 		}
+		if (!eggPluginConfig) return;
 		const logger = this.options.logger;
-		if (!eggPluginConfig) {
-			logger.warn("[@eggjs/core/egg_loader] pkg.eggPlugin is missing in %s, plugin: %j", pluginPackage, plugin);
-			return;
-		}
 		if (eggPluginConfig.name && eggPluginConfig.strict !== false && eggPluginConfig.name !== plugin.name) logger.warn(`[@eggjs/core/egg_loader] pluginName(${plugin.name}) is different from pluginConfigName(${eggPluginConfig.name})`);
 		depCompatible(eggPluginConfig);
 		for (const key of [
@@ -455,10 +481,60 @@ var EggLoader = class {
 		return lookupDirs;
 	}
 	getPluginPath(plugin) {
-		if (plugin.path) return plugin.path;
+		if (plugin.path && !this.#isBundlePluginPathArtifact(plugin.path)) return plugin.path;
 		if (plugin.package) assert(isValidatePackageName(plugin.package), `plugin ${plugin.name} invalid, use 'path' instead of package: "${plugin.package}"`);
+		if (this.#isBundleModeForThisApp() && (!plugin.path || this.#isBundlePluginPathArtifact(plugin.path))) return this.#resolveBundlePluginPath(plugin);
 		return this.#resolvePluginPath(plugin);
 	}
+	/**
+	* In bundle mode a plugin declared via `definePluginFactory({ path: import.meta.dirname })`
+	* carries a `path` rewritten by the bundler to the bundle output directory (= baseDir),
+	* which does not contain the plugin's own files. Detect that case so the plugin is
+	* re-resolved by package name instead.
+	*/
+	/**
+	* Whether an active bundle store belongs to THIS app. The store is shared via globalThis
+	* across @eggjs/core copies, so one registered for a different app must not reinterpret this
+	* app's plugin paths — mirror `ManifestStore.load()`'s `bundleStore.baseDir === baseDir` gate.
+	*/
+	#isBundleModeForThisApp() {
+		const bundleStore = ManifestStore.getBundleStore();
+		return !!bundleStore && path.resolve(bundleStore.baseDir) === path.resolve(this.options.baseDir);
+	}
+	#isBundlePluginPathArtifact(pluginPath) {
+		if (!this.#isBundleModeForThisApp()) return false;
+		return path.resolve(pluginPath) === path.resolve(this.options.baseDir);
+	}
+	/**
+	* Re-resolve a bundle-artifact plugin path to the directory of the plugin package's entry
+	* module — the same directory `definePluginFactory` captured via `import.meta.dirname` at
+	* build time. Built-in framework plugins only carry a `name` (no `package`), so fall back to
+	* the conventional `@eggjs/<name>` package name in addition to the bare name.
+	*/
+	#resolveBundlePluginPath(plugin) {
+		const candidates = plugin.package ? [plugin.package] : plugin.name.includes("/") ? [plugin.name] : [plugin.name, `@eggjs/${plugin.name}`];
+		let lastErr;
+		for (const name$1 of candidates) try {
+			let realDir;
+			try {
+				realDir = path.dirname(utils_default.resolvePath(name$1, { paths: [...this.lookupDirs] }));
+			} catch {
+				realDir = path.dirname(utils_default.resolvePath(`${name$1}/package.json`, { paths: [...this.lookupDirs] }));
+			}
+			const segments = realDir.split(/[/\\]/);
+			const nmIdx = segments.lastIndexOf("node_modules");
+			if (nmIdx !== -1) {
+				const rebased = path.join(this.options.baseDir, ...segments.slice(nmIdx));
+				if (fs.existsSync(rebased)) return rebased;
+			}
+			return realDir;
+		} catch (err) {
+			lastErr = err;
+		}
+		const name = plugin.package || plugin.name;
+		debug("[resolveBundlePluginPath] error: %o, plugin info: %o", lastErr, plugin);
+		throw new Error(`Can not find plugin ${name} in "${[...this.lookupDirs].join(", ")}"`, { cause: lastErr });
+	}
 	#resolvePluginPath(plugin) {
 		const name = plugin.package || plugin.name;
 		try {
@@ -476,7 +552,7 @@ var EggLoader = class {
 			if (isESM) {
 				if (exports.import) realPluginPath = path.join(pluginPath, exports.import);
 			} else if (exports.require) realPluginPath = path.join(pluginPath, exports.require);
-			if (exports.typescript && isSupportTypeScript() && !await exists(realPluginPath)) {
+			if (exports.typescript && isSupportTypeScript() && !this.loaderFS.exists(realPluginPath)) {
 				realPluginPath = path.join(pluginPath, exports.typescript);
 				debug("[formatPluginPathFromPackageJSON] use typescript path %o", realPluginPath);
 			}
@@ -742,14 +818,16 @@ var EggLoader = class {
 	*/
 	async loadCustomApp() {
 		await this.#loadBootHook("app");
-		this.lifecycle.triggerConfigWillLoad();
+		if (this.options.metadataOnly) await this.lifecycle.triggerLoadMetadata();
+		else this.lifecycle.triggerConfigWillLoad();
 	}
 	/**
 	* Load agent.js, same as {@link EggLoader#loadCustomApp}
 	*/
 	async loadCustomAgent() {
 		await this.#loadBootHook("agent");
-		this.lifecycle.triggerConfigWillLoad();
+		if (this.options.metadataOnly) await this.lifecycle.triggerLoadMetadata();
+		else this.lifecycle.triggerConfigWillLoad();
 	}
 	loadBootHook() {}
 	async #loadBootHook(fileName) {
@@ -1042,7 +1120,9 @@ var EggLoader = class {
 			...options,
 			directory: options?.directory ?? directory,
 			target,
-			inject: this.app
+			inject: this.app,
+			manifest: this.manifest,
+			loaderFS: options?.loaderFS ?? this.loaderFS
 		};
 		const timingKey = `Load "${String(property)}" to Application`;
 		this.timing.start(timingKey);
@@ -1061,7 +1141,9 @@ var EggLoader = class {
 			...options,
 			directory: options?.directory || directory,
 			property,
-			inject: this.app
+			inject: this.app,
+			manifest: this.manifest,
+			loaderFS: options?.loaderFS ?? this.loaderFS
 		};
 		const timingKey = `Load "${String(property)}" to Context`;
 		this.timing.start(timingKey);
@@ -1091,14 +1173,110 @@ var EggLoader = class {
 		return files;
 	}
 	resolveModule(filepath) {
+		return this.manifest.resolveModule(filepath, () => this.#doResolveModule(filepath));
+	}
+	#doResolveModule(filepath) {
 		let fullPath;
 		try {
 			fullPath = utils_default.resolvePath(filepath);
-		} catch {
-			return;
-		}
+		} catch {}
+		if (!fullPath) fullPath = this.#resolveFromOutDir(filepath);
 		return fullPath;
 	}
+	#resolveOutDir() {
+		if (this.pkg.egg?.outDir) {
+			debug("[resolveOutDir] use pkg.egg.outDir: %o", this.pkg.egg.outDir);
+			return this.pkg.egg.outDir;
+		}
+		const tsConfigFile = path.join(this.options.baseDir, "tsconfig.json");
+		if (fs.existsSync(tsConfigFile)) try {
+			const tsConfig = JSON.parse(fs.readFileSync(tsConfigFile, "utf-8"));
+			if (tsConfig.compilerOptions?.outDir) {
+				debug("[resolveOutDir] use tsconfig.json compilerOptions.outDir: %o", tsConfig.compilerOptions.outDir);
+				return tsConfig.compilerOptions.outDir;
+			}
+		} catch {}
+	}
+	#resolveFromOutDir(filepath) {
+		if (!this.outDir) return;
+		const baseDir = this.options.baseDir;
+		if (!filepath.startsWith(baseDir + path.sep)) return;
+		const relativePath = path.relative(baseDir, filepath);
+		for (const ext of [".js", ".mjs"]) {
+			const outDirPath = path.join(baseDir, this.outDir, relativePath + ext);
+			if (fs.existsSync(outDirPath)) {
+				debug("[resolveModule:outDir] %o => %o", filepath, outDirPath);
+				return outDirPath;
+			}
+		}
+	}
+	/**
+	* Generate startup manifest from collected data.
+	* Should be called after all loading phases complete.
+	*/
+	generateManifest() {
+		const manifest = this.manifest.generateManifest({
+			serverEnv: this.serverEnv,
+			serverScope: this.serverScope,
+			typescriptEnabled: isSupportTypeScript()
+		});
+		this.#collectConventionalDynamicFiles(manifest);
+		return manifest;
+	}
+	/**
+	* metadataOnly startup intentionally skips the agent process, but bundled
+	* single-mode workers still load agent boot hooks and agent extends later.
+	* Record convention-based dynamic entry points so the bundle can satisfy
+	* those runtime lookups without running agent lifecycle hooks at manifest
+	* generation time.
+	*/
+	#collectConventionalDynamicFiles(manifest) {
+		const resolveCacheTargets = new Set(Object.values(manifest.resolveCache).filter((target) => typeof target === "string"));
+		for (const unit of this.getLoadUnits()) {
+			this.#collectConventionFile(manifest, path.join(unit.path, "package.json"), resolveCacheTargets);
+			for (const load of CONVENTIONAL_MANIFEST_LOADS) {
+				const target = path.join(unit.path, ...load.path);
+				if (load.type === "resolve") this.#collectConventionResolve(manifest, target, resolveCacheTargets);
+				else if ("extensionlessResolve" in load && load.extensionlessResolve) this.#collectConventionFileResolves(manifest, target, resolveCacheTargets);
+				else this.#collectConventionFileDiscovery(manifest, target);
+			}
+		}
+	}
+	#collectConventionResolve(manifest, request, resolveCacheTargets) {
+		const requestKey = this.#toManifestRel(request);
+		if (Object.hasOwn(manifest.resolveCache, requestKey)) return;
+		const resolved = this.#doResolveModule(request);
+		const resolvedKey = resolved ? this.#toManifestRel(resolved) : null;
+		manifest.resolveCache[requestKey] = resolvedKey;
+		if (resolvedKey !== null) resolveCacheTargets.add(resolvedKey);
+	}
+	#collectConventionFileResolves(manifest, directory, resolveCacheTargets) {
+		const files = this.#collectConventionFileDiscovery(manifest, directory);
+		for (const file of files) {
+			const ext = path.extname(file);
+			if (!ext) continue;
+			const request = path.join(directory, file.slice(0, -ext.length));
+			this.#collectConventionResolve(manifest, request, resolveCacheTargets);
+		}
+	}
+	#collectConventionFileDiscovery(manifest, directory) {
+		const dirKey = this.#toManifestRel(directory);
+		if (Object.hasOwn(manifest.fileDiscovery, dirKey)) return manifest.fileDiscovery[dirKey];
+		manifest.fileDiscovery[dirKey] = fs.existsSync(directory) && fs.statSync(directory).isDirectory() ? globby.sync(FileLoader.getDefaultMatch(), { cwd: directory }).sort() : [];
+		return manifest.fileDiscovery[dirKey];
+	}
+	#collectConventionFile(manifest, filepath, resolveCacheTargets) {
+		const fileKey = this.#toManifestRel(filepath);
+		if (resolveCacheTargets.has(fileKey)) return;
+		if (!fs.existsSync(filepath) || !fs.statSync(filepath).isFile()) return;
+		const dirKey = this.#toManifestRel(path.dirname(filepath));
+		const basename = path.basename(filepath);
+		const files = manifest.fileDiscovery[dirKey] ?? [];
+		if (!files.includes(basename)) manifest.fileDiscovery[dirKey] = [...files, basename].sort();
+	}
+	#toManifestRel(filepath) {
+		return (path.isAbsolute(filepath) ? path.relative(this.options.baseDir, filepath) : filepath).replaceAll(path.sep, "/");
+	}
 };
 function depCompatible(plugin) {
 	if (plugin.dep && !(Array.isArray(plugin.dependencies) && plugin.dependencies.length > 0)) {

package/dist/loader/file_loader.d.ts

@@ -1,4 +1,5 @@
-import { Fun } from "../utils/index.js";
+import { ManifestStore } from "./manifest.js";
+import { LoaderFS } from "@eggjs/loader-fs";
 
 //#region src/loader/file_loader.d.ts
 declare const FULLPATH: unique symbol;
@@ -37,12 +38,17 @@ interface FileLoaderOptions {
   /** set property's case when converting a filepath to property list. */
   caseStyle?: CaseStyle | CaseStyleFunction;
   lowercaseFirst?: boolean;
+  /** Startup manifest for caching globby scans and collecting results */
+  manifest?: ManifestStore;
+  /** Loader-facing filesystem abstraction */
+  loaderFS?: LoaderFS;
 }
 interface FileLoaderParseItem {
   fullpath: string;
   properties: string[];
-  exports: object | Fun;
+  exports: unknown;
 }
+type NormalizedFileLoaderOptions = FileLoaderOptions & Required<Pick<FileLoaderOptions, "caseStyle" | "loaderFS">>;
 /**
 * Load files from directory to target object.
 * @since 1.0.0
@@ -50,7 +56,8 @@ interface FileLoaderParseItem {
 declare class FileLoader {
   static get FULLPATH(): typeof FULLPATH;
   static get EXPORTS(): typeof EXPORTS;
-  readonly options: FileLoaderOptions & Required<Pick<FileLoaderOptions, "caseStyle">>;
+  static getDefaultMatch(): string[];
+  readonly options: NormalizedFileLoaderOptions;
   /**
   * @class
   * @param {Object} options - options

package/dist/loader/file_loader.js

@@ -1,11 +1,10 @@
 import utils_default from "../utils/index.js";
-import fs from "node:fs";
 import path from "node:path";
 import { debuglog } from "node:util";
 import { isSupportTypeScript } from "@eggjs/utils";
 import assert from "node:assert";
 import { isAsyncFunction, isClass, isGeneratorFunction, isPrimitive } from "is-type-of";
-import globby from "globby";
+import { RealLoaderFS } from "@eggjs/loader-fs";
 
 //#region src/loader/file_loader.ts
 const debug = debuglog("egg/core/file_loader");
@@ -16,17 +15,23 @@ const CaseStyle = {
 	lower: "lower",
 	upper: "upper"
 };
+function getDefaultFileLoaderMatch() {
+	return isSupportTypeScript() ? ["**/*.(js|ts|mjs|cjs)", "!**/*.d.ts"] : ["**/*.{js,mjs,cjs}"];
+}
 /**
 * Load files from directory to target object.
 * @since 1.0.0
 */
-var FileLoader = class {
+var FileLoader = class FileLoader {
 	static get FULLPATH() {
 		return FULLPATH;
 	}
 	static get EXPORTS() {
 		return EXPORTS;
 	}
+	static getDefaultMatch() {
+		return getDefaultFileLoaderMatch();
+	}
 	options;
 	/**
 	* @class
@@ -45,10 +50,12 @@ var FileLoader = class {
 	constructor(options) {
 		assert(options.directory, "options.directory is required");
 		assert(options.target, "options.target is required");
+		if (!options.manifest && options.inject) options.manifest = options.inject.loader?.manifest;
 		this.options = {
 			caseStyle: CaseStyle.camel,
 			call: true,
 			override: false,
+			loaderFS: new RealLoaderFS(),
 			...options
 		};
 		if (this.options.lowercaseFirst === true) {
@@ -114,7 +121,7 @@ var FileLoader = class {
 	async parse() {
 		let files = this.options.match;
 		if (files) files = Array.isArray(files) ? files : [files];
-		else files = isSupportTypeScript() ? ["**/*.(js|ts)", "!**/*.d.ts"] : ["**/*.js"];
+		else files = FileLoader.getDefaultMatch();
 		let ignore = this.options.ignore;
 		if (ignore) {
 			ignore = Array.isArray(ignore) ? ignore : [ignore];
@@ -127,13 +134,14 @@ var FileLoader = class {
 		const items = [];
 		debug("[parse] parsing directories: %j", directories);
 		for (const directory of directories) {
-			const filepaths = globby.sync(files, { cwd: directory });
-			debug("[parse] globby files: %o, cwd: %o => %o", files, directory, filepaths);
+			const manifest = this.options.manifest;
+			const filepaths = manifest ? manifest.globFiles(directory, () => this.options.loaderFS.glob(files, { cwd: directory })) : this.options.loaderFS.glob(files, { cwd: directory });
+			debug("[parse] files: %o, cwd: %o => %o", files, directory, filepaths);
 			for (const filepath of filepaths) {
 				const fullpath = path.join(directory, filepath);
-				if (!fs.statSync(fullpath).isFile()) continue;
-				if (filepath.endsWith(".js")) {
-					const filepathTs = filepath.replace(/\.js$/, ".ts");
+				if (!this.options.loaderFS.stat(fullpath).isFile()) continue;
+				if (filepath.endsWith(".js") || filepath.endsWith(".mjs") || filepath.endsWith(".cjs")) {
+					const filepathTs = filepath.replace(/\.(?:js|mjs|cjs)$/, ".ts");
 					if (filepaths.includes(filepathTs)) {
 						debug("[parse] ignore %s, because %s exists", fullpath, filepathTs);
 						continue;
@@ -167,7 +175,7 @@ function getProperties(filepath, caseStyle) {
 	return defaultCamelize(filepath, caseStyle);
 }
 async function getExports(fullpath, options, pathName) {
-	let exports = await utils_default.loadFile(fullpath);
+	let exports = await options.loaderFS.loadFile(fullpath);
 	if (options.initializer) {
 		exports = options.initializer(exports, {
 			path: fullpath,

package/dist/loader/loader_fs.d.ts

@@ -0,0 +1,17 @@
+import { ManifestStore } from "./manifest.js";
+import { Stats } from "node:fs";
+import { LoaderFS as LoaderFS$1, LoaderFSGlobOptions } from "@eggjs/loader-fs";
+
+//#region src/loader/loader_fs.d.ts
+declare class ManifestLoaderFS implements LoaderFS$1 {
+  #private;
+  constructor(manifest: ManifestStore, fallback?: LoaderFS$1);
+  exists(filepath: string): boolean;
+  stat(filepath: string): Stats;
+  realpath(filepath: string): string;
+  readJSON<T = unknown>(filepath: string): T;
+  glob(patterns: string | string[], options?: LoaderFSGlobOptions): string[];
+  loadFile(filepath: string): Promise<unknown>;
+}
+//#endregion
+export { type LoaderFS$1 as LoaderFS, ManifestLoaderFS };