bun-workspaces 1.8.2 → 1.10.0

package/src/workspaces/dependencyGraph/validateDependencyRules.mjs

@@ -17,7 +17,7 @@ const getTransitiveDeps = (workspaceName, workspaceMap, chain, visited) => {
   }
   return result;
 };
-const validateWorkspaceDependencyRules = ({ workspaceMap }) => {
+const validateWorkspaceDependencyRules = ({ workspaceMap, rootWorkspace }) => {
   const violations = [];
   for (const [workspaceName, { config }] of Object.entries(workspaceMap)) {
     const rule = config.rules?.workspaceDependencies;
@@ -32,10 +32,15 @@ const validateWorkspaceDependencyRules = ({ workspaceMap }) => {
       const depWorkspace = workspaceMap[depName]?.workspace;
       if (!depWorkspace) continue;
       const chainStr = chain.join(" -> ");
+      // matchWorkspacesByPatterns can inject the root workspace when an
+      // "@root" pattern is present, even if it isn't in the input universe.
+      // We're only asking "does the single dep match?" so confirm by name.
       if (rule.allowPatterns) {
-        const isAllowed =
-          matchWorkspacesByPatterns(rule.allowPatterns, [depWorkspace]).length >
-          0;
+        const isAllowed = matchWorkspacesByPatterns(
+          rule.allowPatterns,
+          [depWorkspace],
+          rootWorkspace,
+        ).some((matched) => matched.name === depWorkspace.name);
         if (!isAllowed) {
           violations.push(
             `"${workspaceName}" violates workspaceDependencies rule: workspace "${depName}" is not permitted by allowPatterns (dependency chain: ${chainStr})`,
@@ -44,9 +49,11 @@ const validateWorkspaceDependencyRules = ({ workspaceMap }) => {
         }
       }
       if (rule.denyPatterns) {
-        const isDenied =
-          matchWorkspacesByPatterns(rule.denyPatterns, [depWorkspace]).length >
-          0;
+        const isDenied = matchWorkspacesByPatterns(
+          rule.denyPatterns,
+          [depWorkspace],
+          rootWorkspace,
+        ).some((matched) => matched.name === depWorkspace.name);
         if (isDenied) {
           violations.push(
             `"${workspaceName}" violates workspaceDependencies rule: workspace "${depName}" is denied by denyPatterns (dependency chain: ${chainStr})`,

package/src/workspaces/findWorkspaces.mjs

@@ -144,6 +144,7 @@ const findWorkspaces = ({
         tags: workspaceConfig?.tags ?? [],
         dependencies: [],
         dependents: [],
+        externalDependencies: [],
       };
       if (workspace.isRoot) {
         logger.debug(`Found root workspace: ${workspace.name}`);
@@ -177,10 +178,12 @@ const findWorkspaces = ({
       workspaceMap,
       workspaceAliases,
       workspacePatternConfigs,
+      rootWorkspace,
     );
   }
   validateWorkspaceDependencyRules({
     workspaceMap,
+    rootWorkspace,
   });
   validateWorkspaceAliases(workspaces, workspaceAliases, rootWorkspace.name);
   logger.debug(

package/src/workspaces/workspace.mjs

@@ -1,3 +1,9 @@
-/** Metadata about a nested package within a Bun monorepo */
+/** Catalog reference info attached to an `ExternalDependency` that uses a `catalog:` ref */ /** The four `package.json` dependency maps a dep can be declared in */ const EXTERNAL_DEPENDENCY_SOURCES =
+  [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+  ];
 
-export {};
+export { EXTERNAL_DEPENDENCY_SOURCES };

package/src/workspaces/workspacePattern.mjs

@@ -12,95 +12,183 @@ const WORKSPACE_PATTERN_NEGATION_PREFIXES = [
   WORKSPACE_PATTERN_NEGATION_SHORT_PREFIX,
 ];
 const WORKSPACE_PATTERN_SEPARATOR = ":";
+const WORKSPACE_PATTERN_REGEX_PREFIX = "re:";
+const validateRegexSource = (source, originalPattern) => {
+  try {
+    new RegExp(source);
+  } catch (cause) {
+    throw new WORKSPACE_PATTERN_ERRORS.InvalidWorkspacePattern(
+      `Invalid regex in workspace pattern "${originalPattern}": ${cause.message}`,
+    );
+  }
+};
 const parseWorkspacePattern = (pattern) => {
   const negationPrefix = WORKSPACE_PATTERN_NEGATION_PREFIXES.find((prefix) =>
     pattern.startsWith(prefix),
   );
   const isNegated = !!negationPrefix;
-  const patternValue = negationPrefix
+  const afterNegation = negationPrefix
     ? pattern.slice(negationPrefix.length)
     : pattern;
+  // The "@root" selector resolves to the project's root workspace. Recognized
+  // immediately after optional negation, so "not:@root" / "!@root" also work.
+  // A target-scoped value of "@root" (e.g. "name:@root") is treated as a literal,
+  // not a root selector.
+  if (afterNegation === /* inlined export .ROOT_WORKSPACE_SELECTOR */ "@root") {
+    return {
+      target: "default",
+      value: /* inlined export .ROOT_WORKSPACE_SELECTOR */ "@root",
+      isNegated,
+      isRegex: false,
+      isRootSelector: true,
+    };
+  }
+  // "re:" before any target consumes the rest as a regex against the default target.
+  // e.g. "re:path:foo" → default-target regex over literal source "path:foo".
+  if (afterNegation.startsWith(WORKSPACE_PATTERN_REGEX_PREFIX)) {
+    const value = afterNegation.slice(WORKSPACE_PATTERN_REGEX_PREFIX.length);
+    validateRegexSource(value, pattern);
+    return {
+      target: "default",
+      value,
+      isNegated,
+      isRegex: true,
+      isRootSelector: false,
+    };
+  }
   const target = TARGETS.find((target) =>
-    patternValue.startsWith(target + WORKSPACE_PATTERN_SEPARATOR),
+    afterNegation.startsWith(target + WORKSPACE_PATTERN_SEPARATOR),
   );
   if (!target) {
     return {
       target: "default",
-      value: patternValue,
+      value: afterNegation,
       isNegated,
+      isRegex: false,
+      isRootSelector: false,
     };
   }
-  const value = patternValue.slice(
+  const afterTarget = afterNegation.slice(
     target.length + WORKSPACE_PATTERN_SEPARATOR.length,
   );
+  if (afterTarget.startsWith(WORKSPACE_PATTERN_REGEX_PREFIX)) {
+    const value = afterTarget.slice(WORKSPACE_PATTERN_REGEX_PREFIX.length);
+    validateRegexSource(value, pattern);
+    return {
+      target,
+      value,
+      isNegated,
+      isRegex: true,
+      isRootSelector: false,
+    };
+  }
   return {
     target,
-    value,
+    value: afterTarget,
     isNegated,
+    isRegex: false,
+    isRootSelector: false,
   };
 };
-const stringifyWorkspacePattern = (pattern) => {
-  return `${pattern.target}${WORKSPACE_PATTERN_SEPARATOR}${pattern.value}`;
-};
 const PATTERN_TARGET_HANDLERS = {
-  default: (pattern, workspaces, wildcardRegex) => {
-    return workspaces.filter((workspace) => {
-      return (
-        (pattern.value.includes("*")
-          ? wildcardRegex.test(workspace.name)
-          : workspace.name === pattern.value) ||
-        workspace.aliases.some((alias) =>
-          pattern.value.includes("*")
-            ? wildcardRegex.test(alias)
-            : alias === pattern.value,
-        )
+  default: (pattern, workspaces) => {
+    // Plain string at the default target matches name OR alias. Wildcard and
+    // regex forms intentionally narrow to name only to avoid ambiguity — use
+    // an explicit "alias:" prefix to match aliases by wildcard/regex.
+    if (pattern.isRegex) {
+      const regex = new RegExp(pattern.value);
+      return workspaces.filter((workspace) => regex.test(workspace.name));
+    }
+    if (pattern.value.includes("*")) {
+      const wildcardRegex = createWildcardRegex(pattern.value);
+      return workspaces.filter((workspace) =>
+        wildcardRegex.test(workspace.name),
       );
-    });
+    }
+    return workspaces.filter(
+      (workspace) =>
+        workspace.name === pattern.value ||
+        workspace.aliases.includes(pattern.value),
+    );
   },
-  name: (pattern, workspaces, wildcardRegex) => {
-    return workspaces.filter((workspace) => {
-      return pattern.value.includes("*")
-        ? wildcardRegex.test(workspace.name)
-        : workspace.name === pattern.value;
-    });
+  name: (pattern, workspaces) => {
+    if (pattern.isRegex) {
+      const regex = new RegExp(pattern.value);
+      return workspaces.filter((workspace) => regex.test(workspace.name));
+    }
+    if (pattern.value.includes("*")) {
+      const wildcardRegex = createWildcardRegex(pattern.value);
+      return workspaces.filter((workspace) =>
+        wildcardRegex.test(workspace.name),
+      );
+    }
+    return workspaces.filter((workspace) => workspace.name === pattern.value);
   },
-  alias: (pattern, workspaces, wildcardRegex) => {
-    return workspaces.filter((workspace) => {
-      return pattern.value.includes("*")
-        ? workspace.aliases.some((alias) => wildcardRegex.test(alias))
-        : workspace.aliases.includes(pattern.value);
-    });
+  alias: (pattern, workspaces) => {
+    if (pattern.isRegex) {
+      const regex = new RegExp(pattern.value);
+      return workspaces.filter((workspace) =>
+        workspace.aliases.some((alias) => regex.test(alias)),
+      );
+    }
+    if (pattern.value.includes("*")) {
+      const wildcardRegex = createWildcardRegex(pattern.value);
+      return workspaces.filter((workspace) =>
+        workspace.aliases.some((alias) => wildcardRegex.test(alias)),
+      );
+    }
+    return workspaces.filter((workspace) =>
+      workspace.aliases.includes(pattern.value),
+    );
   },
   path: (pattern, workspaces) => {
+    if (pattern.isRegex) {
+      const regex = new RegExp(pattern.value);
+      // Normalize backslashes so regex sources stay portable: a single
+      // forward-slash-based regex works on both Windows and POSIX paths.
+      return workspaces.filter((workspace) =>
+        regex.test(workspace.path.replaceAll("\\", "/")),
+      );
+    }
     return workspaces.filter((workspace) =>
       new bun.Glob(pattern.value.replace(/\/+$/, "")).match(workspace.path),
     );
   },
-  tag: (pattern, workspaces, wildcardRegex) => {
+  tag: (pattern, workspaces) => {
+    if (pattern.isRegex) {
+      const regex = new RegExp(pattern.value);
+      return workspaces.filter((workspace) =>
+        workspace.tags.some((tag) => regex.test(tag)),
+      );
+    }
+    if (pattern.value.includes("*")) {
+      const wildcardRegex = createWildcardRegex(pattern.value);
+      return workspaces.filter((workspace) =>
+        workspace.tags.some((tag) => wildcardRegex.test(tag)),
+      );
+    }
     return workspaces.filter((workspace) =>
-      pattern.value.includes("*")
-        ? workspace.tags.some((tag) => wildcardRegex.test(tag))
-        : workspace.tags.includes(pattern.value),
+      workspace.tags.includes(pattern.value),
     );
   },
 };
-const matchWorkspacesByPattern = (pattern, workspaces) =>
-  PATTERN_TARGET_HANDLERS[pattern.target](
-    pattern,
-    workspaces,
-    createWildcardRegex(pattern.value),
-  );
-const matchWorkspacesByPatterns = (patterns, workspaces) => {
+const matchWorkspacesByPattern = (pattern, workspaces, rootWorkspace) => {
+  if (pattern.isRootSelector) {
+    return rootWorkspace ? [rootWorkspace] : [];
+  }
+  return PATTERN_TARGET_HANDLERS[pattern.target](pattern, workspaces);
+};
+const matchWorkspacesByPatterns = (patterns, workspaces, rootWorkspace) => {
   const parsedPatterns = patterns.map(parseWorkspacePattern);
   const excludePatterns = parsedPatterns.filter((pattern) => pattern.isNegated);
   const includePatterns = parsedPatterns.filter(
     (pattern) => !pattern.isNegated,
   );
   const excludeWorkspaces = excludePatterns.flatMap((pattern) =>
-    matchWorkspacesByPattern(pattern, workspaces),
+    matchWorkspacesByPattern(pattern, workspaces, rootWorkspace),
   );
   const includeWorkspaces = includePatterns.flatMap((pattern) =>
-    matchWorkspacesByPattern(pattern, workspaces),
+    matchWorkspacesByPattern(pattern, workspaces, rootWorkspace),
   );
   return includeWorkspaces.filter(
     (workspace, index, arr) =>
@@ -118,8 +206,8 @@ export {
   WORKSPACE_PATTERN_NEGATION_PREFIX,
   WORKSPACE_PATTERN_NEGATION_PREFIXES,
   WORKSPACE_PATTERN_NEGATION_SHORT_PREFIX,
+  WORKSPACE_PATTERN_REGEX_PREFIX,
   WORKSPACE_PATTERN_SEPARATOR,
   matchWorkspacesByPatterns,
   parseWorkspacePattern,
-  stringifyWorkspacePattern,
 };