bun-workspaces 1.8.2 → 1.10.0

package/src/project/implementations/fileSystemProject/affectedWorkspaces.mjs

@@ -0,0 +1,227 @@
+import fs from "fs";
+import path from "path";
+import bun from "bun";
+import { getFileAffectedWorkspaces } from "../../../affected/fileAffectedWorkspaces.mjs";
+import { getGitAffectedWorkspaces } from "../../../affected/gitAffectedWorkspaces.mjs";
+
+const isOptionsForDiffSource = (options, diffSource) =>
+  options.diffSource === diffSource;
+const DEFAULT_INPUT_FILE_PATTERN = ".";
+const DEFAULT_HEAD_REF = "HEAD";
+const BUN_LOCK_PROJECT_RELATIVE_PATH = "bun.lock";
+const FILE_PATTERN_NEGATION_PREFIX = "!";
+const GLOB_CHARACTER_REGEX = /[*?[{]/;
+const SKIPPED_DIR_NAMES = new Set(["node_modules", ".git"]);
+const buildWorkspaceInputs = ({ project, script }) => {
+  const effectiveInputsByName = new Map();
+  const inputs = project.workspaces.map((workspace) => {
+    const workspaceConfig = project.config.workspaces[workspace.name];
+    const scriptInputs = script
+      ? workspaceConfig?.scripts[script]?.inputs
+      : undefined;
+    const sourceInputs = scriptInputs ?? workspaceConfig?.defaultInputs ?? {};
+    const effectiveFiles = sourceInputs.files ?? [DEFAULT_INPUT_FILE_PATTERN];
+    const effectiveWorkspacePatterns = sourceInputs.workspacePatterns ?? [];
+    const effectiveExternalDependencies = sourceInputs.externalDependencies;
+    effectiveInputsByName.set(workspace.name, {
+      files: effectiveFiles,
+      workspacePatterns: effectiveWorkspacePatterns,
+      ...(effectiveExternalDependencies !== undefined && {
+        externalDependencies: effectiveExternalDependencies,
+      }),
+    });
+    return {
+      workspace,
+      inputFilePatterns: effectiveFiles,
+      inputWorkspacePatterns: effectiveWorkspacePatterns,
+      ...(effectiveExternalDependencies !== undefined && {
+        inputExternalDependencyNames: effectiveExternalDependencies,
+      }),
+    };
+  });
+  return {
+    inputs,
+    effectiveInputsByName,
+  };
+};
+const buildLockfileChangeSyntheticEntries = (workspaces) => {
+  const result = new Map();
+  for (const workspace of workspaces) {
+    if (!workspace.externalDependencies.length) continue;
+    result.set(
+      workspace.name,
+      workspace.externalDependencies.map(({ name, source }) => ({
+        name,
+        source,
+        baseVersion: null,
+        headVersion: null,
+      })),
+    );
+  }
+  return result;
+};
+const normalizeChangedFilesPattern = (pattern) => {
+  let normalized = pattern.replaceAll("\\", "/");
+  while (normalized.startsWith("./")) normalized = normalized.slice(2);
+  normalized = normalized.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (normalized === ".") return "";
+  return normalized;
+};
+const expandPatternToFiles = ({ rootDirectory, pattern }) => {
+  if (!pattern) return [];
+  const normalized = normalizeChangedFilesPattern(pattern);
+  if (normalized && GLOB_CHARACTER_REGEX.test(normalized)) {
+    return Array.from(
+      new bun.Glob(normalized).scanSync({
+        cwd: rootDirectory,
+        onlyFiles: true,
+      }),
+    ).map((match) => match.replaceAll("\\", "/"));
+  }
+  // Empty `normalized` means the input resolved to the project root (e.g. ".")
+  const isProjectRoot = normalized === "";
+  const absolute = isProjectRoot
+    ? rootDirectory
+    : path.join(rootDirectory, ...normalized.split("/"));
+  let stat;
+  try {
+    stat = fs.statSync(absolute);
+  } catch {
+    // Pass through paths that don't exist on disk (e.g. deleted files)
+    return isProjectRoot ? [] : [normalized];
+  }
+  if (stat.isFile()) return [normalized];
+  if (!stat.isDirectory()) return [];
+  const result = [];
+  const walk = (dir, baseRel) => {
+    for (const entry of fs.readdirSync(dir, {
+      withFileTypes: true,
+    })) {
+      if (entry.isDirectory() && SKIPPED_DIR_NAMES.has(entry.name)) continue;
+      const rel = baseRel ? `${baseRel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(path.join(dir, entry.name), rel);
+      } else if (entry.isFile()) {
+        result.push(rel);
+      }
+    }
+  };
+  walk(absolute, normalized);
+  return result;
+};
+const expandChangedFilesPatterns = ({ rootDirectory, patterns }) => {
+  const includes = new Set();
+  const excludes = new Set();
+  for (const pattern of patterns) {
+    const isExclude = pattern.startsWith(FILE_PATTERN_NEGATION_PREFIX);
+    const stripped = isExclude
+      ? pattern.slice(FILE_PATTERN_NEGATION_PREFIX.length)
+      : pattern;
+    const target = isExclude ? excludes : includes;
+    for (const expanded of expandPatternToFiles({
+      rootDirectory,
+      pattern: stripped,
+    })) {
+      target.add(expanded);
+    }
+  }
+  for (const excluded of excludes) {
+    includes.delete(excluded);
+  }
+  return [...includes];
+};
+const toAffectedWorkspaceResult = (internal, effectiveInputsByName) => ({
+  workspace: internal.workspace,
+  inputs: effectiveInputsByName.get(internal.workspace.name) ?? {},
+  isAffected: internal.isAffected,
+  affectedReasons: {
+    changedFiles: internal.affectedReasons.changedFiles.map((file) => ({
+      projectFilePath: file.filePath,
+      inputMatch: file.inputPattern,
+      ...(file.fileMetadata?.git && {
+        gitReasons: file.fileMetadata.git.reasons,
+      }),
+    })),
+    dependencies: internal.affectedReasons.dependencies,
+    externalDependencies: internal.affectedReasons.externalDependencies,
+  },
+});
+const determineAffectedWorkspaces = async (project, options) => {
+  const ignoreWorkspaceDependencies =
+    options.ignoreWorkspaceDependencies ?? false;
+  const ignoreExternalDependencies =
+    options.ignoreExternalDependencies ?? false;
+  const { inputs: workspaceInputs, effectiveInputsByName } =
+    buildWorkspaceInputs({
+      project,
+      script: options.script,
+    });
+  if (isOptionsForDiffSource(options, "git")) {
+    const baseRef =
+      options.diffOptions?.baseRef ??
+      project.config.root.defaults.affectedBaseRef;
+    const headRef = options.diffOptions?.headRef ?? DEFAULT_HEAD_REF;
+    const { affectedWorkspaces, baseSha, headSha } =
+      await getGitAffectedWorkspaces({
+        rootDirectory: project.rootDirectory,
+        workspacesOptions: {
+          workspaceInputs,
+          workspaces: project.workspaces,
+          rootWorkspace: project.rootWorkspace,
+          ignoreWorkspaceDependencies,
+          ignoreExternalDependencies,
+        },
+        gitOptions: {
+          baseRef,
+          headRef,
+          ignoreUntracked: options.diffOptions?.ignoreUntracked,
+          ignoreStaged: options.diffOptions?.ignoreStaged,
+          ignoreUnstaged: options.diffOptions?.ignoreUnstaged,
+          ignoreUncommitted: options.diffOptions?.ignoreUncommitted,
+        },
+      });
+    return {
+      metadata: {
+        diffSource: "git",
+        git: {
+          baseRef,
+          headRef,
+          baseSha,
+          headSha,
+        },
+      },
+      workspaceResults: affectedWorkspaces.map((result) =>
+        toAffectedWorkspaceResult(result, effectiveInputsByName),
+      ),
+    };
+  }
+  const expandedChangedFilePaths = expandChangedFilesPatterns({
+    rootDirectory: project.rootDirectory,
+    patterns: options.changedFiles,
+  });
+  const lockfileInChangedFiles = expandedChangedFilePaths.includes(
+    BUN_LOCK_PROJECT_RELATIVE_PATH,
+  );
+  const externalDepChangesByWorkspace =
+    !ignoreExternalDependencies && lockfileInChangedFiles
+      ? buildLockfileChangeSyntheticEntries(project.workspaces)
+      : new Map();
+  const { affectedWorkspaces } = await getFileAffectedWorkspaces({
+    rootDirectory: project.rootDirectory,
+    workspaceInputs,
+    changedFilePaths: expandedChangedFilePaths,
+    rootWorkspace: project.rootWorkspace,
+    externalDepChangesByWorkspace,
+    ignoreWorkspaceDependencies,
+  });
+  return {
+    metadata: {
+      diffSource: "fileList",
+    },
+    workspaceResults: affectedWorkspaces.map((result) =>
+      toAffectedWorkspaceResult(result, effectiveInputsByName),
+    ),
+  };
+};
+
+export { determineAffectedWorkspaces, isOptionsForDiffSource };

package/src/project/implementations/{fileSystemProject.mjs → fileSystemProject/fileSystemProject.mjs}

@@ -1,8 +1,8 @@
 import fs from "fs";
 import path from "path";
-import { loadRootConfig } from "../../config/index.mjs";
-import { getUserEnvVar } from "../../config/userEnvVars/index.mjs";
-import { parse, quote } from "../../internal/bundledDeps/shellQuote.mjs";
+import { loadRootConfig } from "../../../config/index.mjs";
+import { getUserEnvVar } from "../../../config/userEnvVars/index.mjs";
+import { parse, quote } from "../../../internal/bundledDeps/shellQuote.mjs";
 import {
   DEFAULT_TEMP_DIR,
   IS_WINDOWS,
@@ -11,25 +11,55 @@ import {
   isPlainObject,
   validateJSArray,
   validateJSTypes,
-} from "../../internal/core/index.mjs";
-import { logger } from "../../internal/logger/index.mjs";
+} from "../../../internal/core/index.mjs";
+import { logger } from "../../../internal/logger/index.mjs";
 import {
   createScriptRuntimeEnvVars,
   interpolateWorkspaceScriptMetadata,
   runScript,
   runScripts,
-} from "../../runScript/index.mjs";
-import { checkIsRecursiveScript } from "../../runScript/recursion.mjs";
-import { resolveScriptShell } from "../../runScript/scriptShellOption.mjs";
-import { findWorkspaces, sortWorkspaces } from "../../workspaces/index.mjs";
-import { preventDependencyCycles } from "../../workspaces/dependencyGraph/index.mjs";
-import { PROJECT_ERRORS } from "../errors.mjs";
+} from "../../../runScript/index.mjs";
+import { createMultiProcessOutput } from "../../../runScript/output/multiProcessOutput.mjs";
+import { checkIsRecursiveScript } from "../../../runScript/recursion.mjs";
+import { resolveScriptShell } from "../../../runScript/scriptShellOption.mjs";
+import { findWorkspaces, sortWorkspaces } from "../../../workspaces/index.mjs";
+import { preventDependencyCycles } from "../../../workspaces/dependencyGraph/index.mjs";
+import { PROJECT_ERRORS } from "../../errors.mjs";
 import {
   ProjectBase,
   resolveRootWorkspaceSelector,
   resolveWorkspacePath,
-} from "./projectBase.mjs";
+} from "../projectBase.mjs";
+import { determineAffectedWorkspaces } from "./affectedWorkspaces.mjs";
 
+/**
+ * Resolves the script name used to look up script-level inputs in
+ * `runAffectedWorkspaceScript`. Uses the inline-script name when running
+ * an inline command, or the script name otherwise.
+ */ const resolveInputsLookupScriptName = (scriptOptions) => {
+  if (!scriptOptions.inline) return scriptOptions.script;
+  if (typeof scriptOptions.inline === "object") {
+    return scriptOptions.inline.scriptName;
+  }
+  return undefined;
+};
+const createEmptyAffectedRunResult = () => {
+  const now = new Date().toISOString();
+  return {
+    output: createMultiProcessOutput([]),
+    summary: Promise.resolve({
+      totalCount: 0,
+      successCount: 0,
+      failureCount: 0,
+      allSuccess: true,
+      startTimeISO: now,
+      endTimeISO: now,
+      durationMs: 0,
+      scriptResults: [],
+    }),
+    workspaces: [],
+  };
+};
 const quoteArg = (arg, shell) =>
   IS_WINDOWS && shell === "system"
     ? `"${arg.replace(/"/g, '""')}"`
@@ -497,6 +527,133 @@ class _FileSystemProject extends ProjectBase {
       workspaces,
     };
   }
+  /**
+   * Determine the affected workspaces based on the given options.
+   *
+   * Returns a summary of all workspaces, whether they are affected or not,
+   * and the reasons why they are affected.
+   */ async determineAffectedWorkspaces(options) {
+    validateJSTypes(
+      {
+        "diffSource option": {
+          value: options.diffSource,
+          typeofName: "string",
+        },
+        "ignoreWorkspaceDependencies option": {
+          value: options.ignoreWorkspaceDependencies,
+          typeofName: "boolean",
+          optional: true,
+        },
+        "ignoreExternalDependencies option": {
+          value: options.ignoreExternalDependencies,
+          typeofName: "boolean",
+          optional: true,
+        },
+        "script option": {
+          value: options.script,
+          typeofName: "string",
+          optional: true,
+        },
+      },
+      {
+        throw: true,
+      },
+    );
+    if (options.diffSource !== "git" && options.diffSource !== "fileList") {
+      throw new InvalidJSTypeError(
+        `Type error: diffSource option expects "git" | "fileList", received ${JSON.stringify(options.diffSource)}`,
+      );
+    }
+    if (options.diffSource === "git") {
+      validateJSTypes(
+        {
+          "diffOptions option": {
+            value: options.diffOptions,
+            typeofName: "object",
+            optional: true,
+          },
+        },
+        {
+          throw: true,
+        },
+      );
+      if (options.diffOptions !== undefined) {
+        validateJSTypes(
+          {
+            "diffOptions.baseRef option": {
+              value: options.diffOptions.baseRef,
+              typeofName: "string",
+              optional: true,
+            },
+            "diffOptions.headRef option": {
+              value: options.diffOptions.headRef,
+              typeofName: "string",
+              optional: true,
+            },
+            "diffOptions.ignoreUntracked option": {
+              value: options.diffOptions.ignoreUntracked,
+              typeofName: "boolean",
+              optional: true,
+            },
+            "diffOptions.ignoreStaged option": {
+              value: options.diffOptions.ignoreStaged,
+              typeofName: "boolean",
+              optional: true,
+            },
+            "diffOptions.ignoreUnstaged option": {
+              value: options.diffOptions.ignoreUnstaged,
+              typeofName: "boolean",
+              optional: true,
+            },
+            "diffOptions.ignoreUncommitted option": {
+              value: options.diffOptions.ignoreUncommitted,
+              typeofName: "boolean",
+              optional: true,
+            },
+          },
+          {
+            throw: true,
+          },
+        );
+      }
+    } else {
+      validateJSTypes(
+        {
+          "changedFiles option": {
+            value: options.changedFiles,
+            array: true,
+            itemOptions: {
+              typeofName: "string",
+            },
+          },
+        },
+        {
+          throw: true,
+        },
+      );
+    }
+    return determineAffectedWorkspaces(this, options);
+  }
+  /**
+   * Run the script across the affected workspaces.
+   *
+   * Similar to {@link runScriptAcrossWorkspaces}, but only runs the script across the affected workspaces.
+   */ async runAffectedWorkspaceScript({ affectedOptions, scriptOptions }) {
+    const { workspaceResults } = await this.determineAffectedWorkspaces({
+      ...affectedOptions,
+      script: resolveInputsLookupScriptName(scriptOptions),
+    });
+    const affectedNames = workspaceResults
+      .filter(({ isAffected }) => isAffected)
+      .map(({ workspace }) => workspace.name);
+    if (affectedNames.length === 0) {
+      return createEmptyAffectedRunResult();
+    }
+    return this.runScriptAcrossWorkspaces({
+      ...scriptOptions,
+      workspacePatterns: affectedNames,
+    });
+  }
   static #initialized = false;
 }
 /**

package/src/project/implementations/fileSystemProject/index.mjs

@@ -0,0 +1,4 @@
+export * from "./fileSystemProject.mjs";
+export * from "./affectedWorkspaces.mjs";
+
+export {};

package/src/project/implementations/memoryProject.mjs

@@ -112,6 +112,7 @@ class _MemoryProject extends ProjectBase {
       tags: [],
       dependencies: [],
       dependents: [],
+      externalDependencies: [],
     };
     validateWorkspace(this.rootWorkspace);
     for (const workspace of this.workspaces) {

package/src/project/implementations/projectBase.mjs

@@ -130,24 +130,18 @@ class ProjectBase {
     return this.workspaces.filter((workspace) => workspace.tags.includes(tag));
   }
   findWorkspacesByPattern(...workspacePatterns) {
-    const workspaces = [];
-    if (
-      workspacePatterns.includes(
-        /* inlined export .ROOT_WORKSPACE_SELECTOR */ "@root",
-      )
-    ) {
-      workspaces.push(this.rootWorkspace);
-      workspacePatterns = workspacePatterns.filter(
-        (pattern) =>
-          pattern !== /* inlined export .ROOT_WORKSPACE_SELECTOR */ "@root",
-      );
-    }
-    workspaces.push(
-      ...sortWorkspaces(
-        matchWorkspacesByPatterns(workspacePatterns, this.workspaces),
-      ),
+    const matched = matchWorkspacesByPatterns(
+      workspacePatterns,
+      this.workspaces,
+      this.rootWorkspace,
+    );
+    // Preserve historical ordering: root workspace first, then sorted others.
+    const rootName = this.rootWorkspace.name;
+    const rootMatch = matched.find((workspace) => workspace.name === rootName);
+    const rest = sortWorkspaces(
+      matched.filter((workspace) => workspace.name !== rootName),
     );
-    return workspaces;
+    return rootMatch ? [rootMatch, ...rest] : rest;
   }
   createScriptCommand(options) {
     validateJSTypes(

package/src/project/index.mjs

@@ -1,6 +1,6 @@
 export * from "./errors.mjs";
 export * from "./implementations/projectBase.mjs";
-export * from "./implementations/fileSystemProject.mjs";
+export * from "./implementations/fileSystemProject/index.mjs";
 export * from "./implementations/memoryProject.mjs";
 
 export {};

package/src/rslib-runtime.mjs

@@ -21,42 +21,11 @@ function __webpack_require__(moduleId) {
 // expose the modules object (__webpack_modules__)
 __webpack_require__.m = __webpack_modules__;
 
-// webpack/runtime/compat_get_default_export
-(() => {
-  // getDefaultExport function for compatibility with non-ESM modules
-  __webpack_require__.n = (module) => {
-    var getter =
-      module && module.__esModule ? () => module["default"] : () => module;
-    __webpack_require__.d(getter, { a: getter });
-    return getter;
-  };
-})();
-// webpack/runtime/define_property_getters
-(() => {
-  __webpack_require__.d = (exports, definition) => {
-    for (var key in definition) {
-      if (
-        __webpack_require__.o(definition, key) &&
-        !__webpack_require__.o(exports, key)
-      ) {
-        Object.defineProperty(exports, key, {
-          enumerable: true,
-          get: definition[key],
-        });
-      }
-    }
-  };
-})();
 // webpack/runtime/esm_register_module
 (() => {
   __webpack_require__.add = function registerModules(modules) {
     Object.assign(__webpack_require__.m, modules);
   };
 })();
-// webpack/runtime/has_own_property
-(() => {
-  __webpack_require__.o = (obj, prop) =>
-    Object.prototype.hasOwnProperty.call(obj, prop);
-})();
 
 export { __webpack_require__ };

package/src/workspaces/applyWorkspacePatternConfigs.mjs

@@ -4,11 +4,20 @@ import {
 } from "../config/index.mjs";
 import { matchWorkspacesByPatterns } from "./workspacePattern.mjs";
 
-const resolvedToWorkspaceConfig = ({ aliases, tags, scripts, rules }) => ({
+const resolvedToWorkspaceConfig = ({
+  aliases,
+  tags,
+  scripts,
+  rules,
+  defaultInputs,
+}) => ({
   alias: aliases,
   tags,
   scripts,
   rules,
+  ...(defaultInputs && {
+    defaultInputs,
+  }),
 });
 const makeContext = (workspace) => ({
   name: workspace.name,
@@ -24,9 +33,14 @@ const applyWorkspacePatternConfigs = (
   workspaceMap,
   workspaceAliases,
   patternConfigs,
+  rootWorkspace,
 ) => {
   for (const entry of patternConfigs) {
-    const matched = matchWorkspacesByPatterns(entry.patterns, workspaces);
+    const matched = matchWorkspacesByPatterns(
+      entry.patterns,
+      workspaces,
+      rootWorkspace,
+    );
     for (const workspace of matched) {
       const mapEntry = workspaceMap[workspace.name];
       const prevConfig = mapEntry.config;

package/src/workspaces/dependencyGraph/resolveDependencies.mjs

@@ -1,5 +1,11 @@
 import { resolveCatalogDependencyVersion } from "../packageJson.mjs";
 
+const parseCatalogRef = (rawVersion) => {
+  if (!rawVersion.startsWith("catalog:")) return undefined;
+  return {
+    name: rawVersion.slice("catalog:".length),
+  };
+};
 const resolveWorkspaceDependencies = (
   workspaceMap,
   includeRootWorkspace,
@@ -10,34 +16,78 @@ const resolveWorkspaceDependencies = (
   );
   const workspacesWithDependencies = workspacePackages.map(
     ({ workspace, packageJson }) => {
-      for (const dependencyMap of [
-        packageJson.dependencies,
-        packageJson.devDependencies,
-        packageJson.peerDependencies,
-        packageJson.optionalDependencies,
-      ]) {
-        for (const [dependencyName, dependencyVersion] of Object.entries(
-          dependencyMap,
-        )) {
+      const externalAccumulator = new Map();
+      const dependencyMaps = [
+        {
+          map: packageJson.dependencies,
+          source: "dependencies",
+        },
+        {
+          map: packageJson.devDependencies,
+          source: "devDependencies",
+        },
+        {
+          map: packageJson.peerDependencies,
+          source: "peerDependencies",
+        },
+        {
+          map: packageJson.optionalDependencies,
+          source: "optionalDependencies",
+        },
+      ];
+      for (const { map, source } of dependencyMaps) {
+        for (const [dependencyName, dependencyVersion] of Object.entries(map)) {
+          const catalog = parseCatalogRef(dependencyVersion);
           const resolvedVersion =
-            catalogs && dependencyVersion.startsWith("catalog:")
+            catalogs && catalog
               ? (resolveCatalogDependencyVersion(
                   dependencyName,
                   dependencyVersion,
                   catalogs,
                 ) ?? dependencyVersion)
               : dependencyVersion;
-          if (
-            resolvedVersion.startsWith("workspace:") &&
-            workspaceMap[dependencyName]
-          ) {
-            workspace.dependencies.push(dependencyName);
-            workspaceMap[dependencyName].workspace.dependents.push(
-              workspace.name,
-            );
+          if (resolvedVersion.startsWith("workspace:")) {
+            if (workspaceMap[dependencyName]) {
+              workspace.dependencies.push(dependencyName);
+              workspaceMap[dependencyName].workspace.dependents.push(
+                workspace.name,
+              );
+            }
+            continue;
+          }
+          // External dep — record. Source precedence: a non-`devDependencies`
+          // source overrides `devDependencies`; otherwise the first source
+          // seen wins. Version/catalog reflect the last entry seen for the name.
+          const existing = externalAccumulator.get(dependencyName);
+          if (!existing) {
+            externalAccumulator.set(dependencyName, {
+              source,
+              version: resolvedVersion,
+              catalog,
+            });
+          } else {
+            existing.version = resolvedVersion;
+            existing.catalog = catalog;
+            if (
+              existing.source === "devDependencies" &&
+              source !== "devDependencies"
+            ) {
+              existing.source = source;
+            }
           }
         }
       }
+      workspace.externalDependencies = [...externalAccumulator.entries()]
+        .map(([name, { source, version, catalog }]) => {
+          const entry = {
+            name,
+            version,
+            source,
+          };
+          if (catalog) entry.catalog = catalog;
+          return entry;
+        })
+        .sort((a, b) => a.name.localeCompare(b.name));
       return workspace;
     },
   );