@mastra/deployer 1.68.0-alpha.0 → 1.68.0-alpha.5

package/dist/{analyze-B5HY26Tt.js → analyze-D3eRdXC9.js}

@@ -1,7 +1,6 @@
-import { a as getPackageName, c as isBuiltinModule, f as rollupSafeName, i as getNodeResolveOptions, l as isDependencyPartOfPackage, m as slash, r as getCompiledDepCachePath, s as isBareModuleSpecifier, u as isExternalProtocolImport } from "./utils-DYi43Kp4.js";
-import { i as DepsService } from "./services-B9KRKBT-.js";
-import { a as tsConfigPaths, c as protocolExternalResolver, d as getPackageRootPath, f as esmShim, i as mastraToolsAliasPlugin, o as subpathExternalsResolver, p as esbuild, r as mastraInternalAliasPlugin, s as removeDeployer, u as getPackageMetadata } from "./bundler-CzQiVHzN.js";
-import { spawn } from "child_process";
+import { a as getPackageName, c as isBuiltinModule, f as rollupSafeName, i as getNodeResolveOptions, l as isDependencyPartOfPackage, m as slash, r as getCompiledDepCachePath, s as isBareModuleSpecifier, u as isExternalProtocolImport } from "./utils-Bl3Lm7SI.js";
+import { i as DepsService } from "./services-Lm6PRS4D.js";
+import { a as mastraToolsAliasPlugin, c as removeDeployer, d as getPackageInfo$1, f as getPackageMetadata, h as esbuild, i as mastraInternalAliasPlugin, l as protocolExternalResolver, m as esmShim, o as tsConfigPaths, p as getPackageRootPath, s as subpathExternalsResolver } from "./bundler-CNFQP4Qm.js";
 import { existsSync } from "fs";
 import { readFile, writeFile } from "fs/promises";
 import * as path$1 from "path";
@@ -10,16 +9,16 @@ import { ErrorCategory, ErrorDomain, MastraBaseError, MastraError } from "@mastr
 import virtual from "@rollup/plugin-virtual";
 import * as pkg from "empathic/package";
 import { transformAsync, transformSync, types } from "@babel/core";
-import slugify from "@sindresorhus/slugify";
 import { createWorkspacesCache, findWorkspaces, findWorkspacesRoot } from "find-workspaces";
 import { ensureDir } from "fs-extra";
+import { spawn } from "child_process";
 import { fileURLToPath, pathToFileURL } from "url";
 import commonjs from "@rollup/plugin-commonjs";
 import json from "@rollup/plugin-json";
+import { getPackageInfo, resolveModule } from "local-pkg";
 import { rollup } from "rollup";
 import { optimizeLodashImports } from "@optimize-lodash/rollup-plugin";
 import nodeResolve from "@rollup/plugin-node-resolve";
-import { getPackageInfo } from "local-pkg";
 import { basename as basename$1 } from "path/posix";
 import * as resolve$1 from "resolve.exports";
 //#region \0rolldown/runtime.js
@@ -139,24 +138,6 @@ var import_stack_trace_parser_cjs = /* @__PURE__ */ __toESM((/* @__PURE__ */ __c
 	}
 	exports.parse = parse;
 })))(), 1);
-const isExportTargetImportable = (target) => {
-	if (!target) return false;
-	if (typeof target === "string") return true;
-	if (Array.isArray(target)) return target.some(isExportTargetImportable);
-	if (typeof target !== "object") return false;
-	return Object.values(target).some(isExportTargetImportable);
-};
-const hasRootExport = (exportsField) => {
-	if (exportsField === void 0) return true;
-	if (typeof exportsField === "string" || Array.isArray(exportsField)) return isExportTargetImportable(exportsField);
-	if (!exportsField || typeof exportsField !== "object") return false;
-	const exportMap = exportsField;
-	const exportKeys = Object.keys(exportMap);
-	if (exportKeys.length === 0) return false;
-	if (Object.prototype.hasOwnProperty.call(exportMap, ".")) return isExportTargetImportable(exportMap["."]);
-	if (exportKeys.some((key) => key.startsWith("./"))) return false;
-	return isExportTargetImportable(exportMap);
-};
 /**
 * Create a shared cache for find-workspaces
 */
@@ -193,7 +174,7 @@ async function getWorkspaceInformation({ dir = process.cwd(), mastraEntryFile })
 /**
 * Collects all transitive workspace dependencies and their TGZ paths
 */
-const collectTransitiveWorkspaceDependencies = ({ workspaceMap, initialDependencies, logger }) => {
+const collectTransitiveWorkspaceDependencies = async ({ workspaceMap, initialDependencies, logger }) => {
 	const usedWorkspacePackages = /* @__PURE__ */ new Set();
 	const queue = Array.from(initialDependencies);
 	const resolutions = {};
@@ -208,6 +189,7 @@ const collectTransitiveWorkspaceDependencies = ({ workspaceMap, initialDependenc
 			if (!root) throw new Error("Could not find workspace root");
 			const depsService = new DepsService(root.location);
 			depsService.__setLogger(logger);
+			const slugify = (await import("@sindresorhus/slugify")).default;
 			const sanitizedName = slugify(pkgName);
 			resolutions[pkgName] = depsService.getWorkspaceDependencyPath({
 				pkgName: sanitizedName,
@@ -231,6 +213,7 @@ const packWorkspaceDependencies = async ({ workspaceMap, usedWorkspacePackages,
 	const depsService = new DepsService(root.location);
 	depsService.__setLogger(logger);
 	if (usedWorkspacePackages.size > 0) {
+		const slugify = (await import("@sindresorhus/slugify")).default;
 		const workspaceDirPath = join(bundleOutputDir, "workspace-module");
 		await ensureDir(workspaceDirPath);
 		logger.info("Packaging workspace dependencies", { count: usedWorkspacePackages.size });
@@ -405,7 +388,7 @@ function getInputPlugins$1({ entry, isVirtualFile }, mastraEntry, { sourcemapEna
 * Analyzes both static imports and dynamic imports while filtering out Node.js built-ins and ignored dependencies.
 * Identifies workspace packages and resolves package root paths for proper bundling optimization.
 */
-async function captureDependenciesToOptimize(output, workspaceMap, projectRoot, { logger, shouldCheckTransitiveDependencies }) {
+async function captureDependenciesToOptimize(output, workspaceMap, projectRoot, { logger, mastraEntry, shouldCheckTransitiveDependencies, analyzeCache, activeEntries }) {
 	const depsToOptimize = /* @__PURE__ */ new Map();
 	if (!output.facadeModuleId) throw new Error("Something went wrong, we could not find the package name of the entry file. Please open an issue.");
 	let entryRootPath = projectRoot;
@@ -433,47 +416,55 @@ async function captureDependenciesToOptimize(output, workspaceMap, projectRoot,
 			packageSpec
 		});
 	}
-	const processedWorkspaceDeps = /* @__PURE__ */ new Set();
+	const processedWorkspaceEntries = /* @__PURE__ */ new Set();
 	/**
 	* Recursively discovers transitive workspace dependencies from package manifests.
 	*/
-	function checkTransitiveDependencies(maxDepth = 10, currentDepth = 0) {
-		if (currentDepth >= maxDepth) {
-			logger.warn("Maximum dependency depth reached while checking transitive dependencies.");
-			return;
-		}
+	async function checkTransitiveDependencies() {
 		const depsSnapshot = new Map(depsToOptimize);
-		let hasAddedDeps = false;
 		for (const [dep, meta] of depsSnapshot) {
-			const pkgName = getPackageName(dep);
-			if (!pkgName || !meta.isWorkspace || processedWorkspaceDeps.has(pkgName)) continue;
-			processedWorkspaceDeps.add(pkgName);
-			const workspaceInfo = workspaceMap.get(pkgName);
-			if (!workspaceInfo?.dependencies) continue;
-			for (const [innerDep, _innerDepVersion] of Object.entries(workspaceInfo.dependencies)) {
-				const innerWorkspaceInfo = workspaceMap.get(innerDep);
-				if (!innerWorkspaceInfo) continue;
-				if (!hasRootExport(innerWorkspaceInfo.exports)) continue;
+			if (!getPackageName(dep) || !meta.isWorkspace) continue;
+			const importerPath = pathToFileURL(output.facadeModuleId.startsWith("\0virtual:") ? mastraEntry || projectRoot : output.facadeModuleId).href;
+			const resolvedPath = resolveModule(dep, { paths: [importerPath] });
+			if (!resolvedPath) {
+				logger.warn("Could not resolve path for workspace dependency", { dep });
+				continue;
+			}
+			const resolvedEntry = slash(resolvedPath);
+			if (processedWorkspaceEntries.has(resolvedEntry) || activeEntries.has(resolvedEntry)) continue;
+			processedWorkspaceEntries.add(resolvedEntry);
+			const analysis = await analyzeEntry({
+				entry: resolvedPath,
+				isVirtualFile: false
+			}, mastraEntry, {
+				workspaceMap,
+				projectRoot,
+				logger,
+				sourcemapEnabled: false,
+				shouldCheckTransitiveDependencies: true,
+				analyzeCache,
+				activeEntries
+			});
+			if (!analysis?.dependencies) continue;
+			for (const [innerDep, innerMeta] of analysis.dependencies) {
+				if (!innerMeta.isWorkspace) continue;
 				const existingMeta = depsToOptimize.get(innerDep);
 				if (existingMeta) {
 					depsToOptimize.set(innerDep, {
 						...existingMeta,
-						exports: existingMeta.exports.includes("*") ? existingMeta.exports : [...existingMeta.exports, "*"]
+						exports: [.../* @__PURE__ */ new Set([...existingMeta.exports, ...innerMeta.exports])]
 					});
 					continue;
-				}
-				depsToOptimize.set(innerDep, {
-					exports: ["*"],
-					rootPath: slash(innerWorkspaceInfo.location),
+				} else depsToOptimize.set(innerDep, {
+					exports: innerMeta.exports,
+					rootPath: slash(innerMeta.rootPath || ""),
 					isWorkspace: true,
-					version: innerWorkspaceInfo.version
+					version: innerMeta.version
 				});
-				hasAddedDeps = true;
 			}
 		}
-		if (hasAddedDeps) checkTransitiveDependencies(maxDepth, currentDepth + 1);
 	}
-	if (shouldCheckTransitiveDependencies) checkTransitiveDependencies();
+	if (shouldCheckTransitiveDependencies) await checkTransitiveDependencies();
 	const dynamicImports = output.dynamicImports.filter((d) => !DEPS_TO_IGNORE.includes(d));
 	if (dynamicImports.length) {
 		for (const dynamicImport of dynamicImports) if (!depsToOptimize.has(dynamicImport) && isBareModuleSpecifier(dynamicImport)) {
@@ -498,37 +489,54 @@ async function captureDependenciesToOptimize(output, workspaceMap, projectRoot,
 	}
 	return depsToOptimize;
 }
-async function analyzeEntry({ entry, isVirtualFile }, mastraEntry, { logger, sourcemapEnabled, workspaceMap, projectRoot, shouldCheckTransitiveDependencies = false, analyzeCache }) {
-	const cacheKey = isVirtualFile ? void 0 : slash(entry);
-	if (cacheKey && analyzeCache?.has(cacheKey)) return analyzeCache.get(cacheKey);
-	const optimizerBundler = await rollup({
-		logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
-		input: isVirtualFile ? "#entry" : entry,
-		treeshake: false,
-		preserveSymlinks: true,
-		plugins: getInputPlugins$1({
-			entry,
-			isVirtualFile
-		}, mastraEntry, { sourcemapEnabled }),
-		external: DEPS_TO_IGNORE
-	});
-	const { output } = await optimizerBundler.generate({
-		format: "esm",
-		inlineDynamicImports: true
-	});
-	await optimizerBundler.close();
-	const result = {
-		dependencies: await captureDependenciesToOptimize(output[0], workspaceMap, projectRoot, {
-			logger,
-			shouldCheckTransitiveDependencies
-		}),
-		output: {
-			code: output[0].code,
-			map: output[0].map
-		}
-	};
-	if (cacheKey && analyzeCache) analyzeCache.set(cacheKey, result);
-	return result;
+async function analyzeEntry({ entry, isVirtualFile }, mastraEntry, { logger, sourcemapEnabled, workspaceMap, projectRoot, shouldCheckTransitiveDependencies = false, analyzeCache, activeEntries: providedActiveEntries }) {
+	const resolvedEntry = isVirtualFile ? void 0 : slash(entry);
+	const effectiveAnalyzeCache = analyzeCache ?? /* @__PURE__ */ new Map();
+	const cacheKey = resolvedEntry ? `${resolvedEntry}:${shouldCheckTransitiveDependencies ? "transitive" : "direct"}` : void 0;
+	if (cacheKey && effectiveAnalyzeCache.has(cacheKey)) return effectiveAnalyzeCache.get(cacheKey);
+	const activeEntries = providedActiveEntries ?? /* @__PURE__ */ new Set();
+	const shouldTrackEntry = Boolean(resolvedEntry && !activeEntries.has(resolvedEntry));
+	if (resolvedEntry && shouldTrackEntry) activeEntries.add(resolvedEntry);
+	try {
+		const optimizerBundler = await rollup({
+			logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+			input: isVirtualFile ? "#entry" : entry,
+			treeshake: false,
+			preserveSymlinks: true,
+			plugins: getInputPlugins$1({
+				entry,
+				isVirtualFile
+			}, mastraEntry, { sourcemapEnabled }),
+			external: DEPS_TO_IGNORE
+		});
+		const { output } = await (async () => {
+			try {
+				return await optimizerBundler.generate({
+					format: "esm",
+					inlineDynamicImports: true
+				});
+			} finally {
+				await optimizerBundler.close();
+			}
+		})();
+		const result = {
+			dependencies: await captureDependenciesToOptimize(output[0], workspaceMap, projectRoot, {
+				logger,
+				mastraEntry,
+				shouldCheckTransitiveDependencies,
+				analyzeCache: effectiveAnalyzeCache,
+				activeEntries
+			}),
+			output: {
+				code: output[0].code,
+				map: output[0].map
+			}
+		};
+		if (cacheKey) effectiveAnalyzeCache.set(cacheKey, result);
+		return result;
+	} finally {
+		if (resolvedEntry && shouldTrackEntry) activeEntries.delete(resolvedEntry);
+	}
 }
 //#endregion
 //#region src/build/plugins/hono-alias.ts
@@ -653,7 +661,7 @@ function createVirtualDependencies(depsToOptimize, { projectRoot, workspaceRoot,
 * Configures and returns Rollup plugins for bundling external dependencies.
 * Sets up virtual modules, TypeScript compilation, CommonJS transformation, and workspace resolution.
 */
-async function getInputPlugins(virtualDependencies, { transpilePackages, workspaceMap, bundlerOptions, rootDir, externals, platform }) {
+async function getInputPlugins(virtualDependencies, { transpilePackages, workspaceMap, bundlerOptions, projectRoot, rootDir, externals, platform }) {
 	const transpilePackagesMap = /* @__PURE__ */ new Map();
 	for (const pkg of transpilePackages) {
 		const dir = await getPackageRootPath(pkg);
@@ -665,7 +673,7 @@ async function getInputPlugins(virtualDependencies, { transpilePackages, workspa
 			acc[`#virtual-${dep}`] = virtualDep.virtual;
 			return acc;
 		}, {})),
-		tsConfigPaths(),
+		tsConfigPaths({ cwd: projectRoot }),
 		protocolExternalResolver(),
 		subpathExternalsResolver(externals),
 		transpilePackagesMap.size ? esbuild({
@@ -700,7 +708,11 @@ async function getInputPlugins(virtualDependencies, { transpilePackages, workspa
 			transformMixedEsModules: true,
 			ignoreTryCatch: false
 		}),
-		bundlerOptions.noBundling ? null : nodeResolve(getNodeResolveOptions(platform)),
+		bundlerOptions.noBundling ? null : nodeResolve({
+			...getNodeResolveOptions(platform),
+			rootDir: projectRoot,
+			modulePaths: [path$1.join(rootDir, "node_modules")]
+		}),
 		bundlerOptions.noBundling ? esmShim() : null,
 		aliasHono(),
 		json(),
@@ -713,7 +725,7 @@ async function getInputPlugins(virtualDependencies, { transpilePackages, workspa
 				async handler(id, importer) {
 					if (!importer) return null;
 					if (!id.endsWith(".node")) return null;
-					const packageName = (await getPackageInfo(importer))?.packageJson?.name || id;
+					const packageName = (await getPackageInfo$1(importer))?.packageJson?.name || id;
 					throw new MastraBaseError({
 						id: "DEPLOYER_BUNDLE_EXTERNALS_MISSING_NATIVE_BUILD",
 						domain: ErrorDomain.DEPLOYER,
@@ -741,7 +753,7 @@ export const mastra = new Mastra({
 * Executes the Rollup build process for virtual dependencies using configured plugins.
 * Bundles all virtual dependency modules into optimized ESM files with proper external handling.
 */
-async function buildExternalDependencies(virtualDependencies, { externals, packagesToTranspile, workspaceMap, rootDir, outputDir, bundlerOptions, platform }) {
+async function buildExternalDependencies(virtualDependencies, { externals, packagesToTranspile, workspaceMap, projectRoot, rootDir, outputDir, bundlerOptions, platform }) {
 	/**
 	* If there are no virtual dependencies to bundle, return an empty array to avoid Rollup errors.
 	*/
@@ -751,6 +763,7 @@ async function buildExternalDependencies(virtualDependencies, { externals, packa
 		transpilePackages: packagesToTranspile,
 		workspaceMap,
 		bundlerOptions: { noBundling },
+		projectRoot,
 		rootDir,
 		externals,
 		platform
@@ -873,6 +886,7 @@ async function bundleExternals(depsToOptimize, outputDir, options) {
 		externals: mergedExternals,
 		packagesToTranspile,
 		workspaceMap,
+		projectRoot,
 		rootDir: workspaceRoot || projectRoot,
 		outputDir,
 		bundlerOptions: {
@@ -924,13 +938,13 @@ async function bundleExternals(depsToOptimize, outputDir, options) {
 //#endregion
 //#region src/build/analyze/externals.ts
 function normalizeExternals(externals) {
-	const userExternals = Array.isArray(externals) ? externals : [];
+	const explicitExternals = Array.isArray(externals) ? externals : [];
 	return {
 		externalsPreset: externals === true,
 		mergedExternals: [...new Set([
 			...GLOBAL_EXTERNALS,
 			...DEPRECATED_EXTERNALS,
-			...userExternals
+			...explicitExternals
 		].filter(Boolean))]
 	};
 }
@@ -1272,6 +1286,7 @@ async function analyzeBundle(entries, mastraEntry, { outputDir, projectRoot, pla
 	logger.info("Analyzing dependencies...");
 	const allUsedExternals = /* @__PURE__ */ new Map();
 	const analyzeCache = /* @__PURE__ */ new Map();
+	const activeAnalyzeEntries = /* @__PURE__ */ new Set();
 	for (const entry of entries) {
 		const analyzeResult = await analyzeEntry({
 			entry,
@@ -1282,7 +1297,8 @@ async function analyzeBundle(entries, mastraEntry, { outputDir, projectRoot, pla
 			workspaceMap,
 			projectRoot,
 			shouldCheckTransitiveDependencies: true,
-			analyzeCache
+			analyzeCache,
+			activeEntries: activeAnalyzeEntries
 		});
 		transformSync(analyzeResult.output.code, {
 			filename: "pino-detection.js",
@@ -1400,4 +1416,4 @@ async function analyzeBundle(entries, mastraEntry, { outputDir, projectRoot, pla
 //#endregion
 export { aliasHono as a, packWorkspaceDependencies as c, bundleExternals as i, checkConfigExport as n, collectTransitiveWorkspaceDependencies as o, normalizeExternals as r, getWorkspaceInformation as s, analyzeBundle as t };
 
-//# sourceMappingURL=analyze-B5HY26Tt.js.map
+//# sourceMappingURL=analyze-D3eRdXC9.js.map