bun-workspaces 1.0.1-alpha → 1.0.1

package/src/runScript/scriptShellOption.mjs

@@ -0,0 +1,39 @@
+import {
+  getUserEnvVar,
+  getUserEnvVarName,
+} from "../config/userEnvVars/index.mjs";
+import { BunWorkspacesError } from "../internal/core/error/index.mjs"; // CONCATENATED MODULE: external "../config/userEnvVars/index.mjs"
+// CONCATENATED MODULE: external "../internal/core/error/index.mjs"
+// CONCATENATED MODULE: ./src/runScript/scriptShellOption.ts
+
+const SCRIPT_SHELL_OPTIONS = ["bun", "system"];
+const validateScriptShellOption = (shell, fromEnvVar = false) => {
+  if (!SCRIPT_SHELL_OPTIONS.includes(shell)) {
+    throw new BunWorkspacesError(
+      `Invalid shell option: ${shell} (accepted values: ${SCRIPT_SHELL_OPTIONS.join(", ")})${fromEnvVar ? ` (set by env var ${getUserEnvVarName("scriptShellDefault")})` : ""}`,
+    );
+  }
+  return shell;
+};
+const getScriptShellDefault = () => {
+  const shell = getUserEnvVar("scriptShellDefault");
+  return shell ? validateScriptShellOption(shell, true) : "bun";
+};
+const resolveScriptShell = (shell) => {
+  if (
+    !shell ||
+    shell === "default" ||
+    shell === "undefined" ||
+    shell === "null"
+  ) {
+    return getScriptShellDefault();
+  }
+  return validateScriptShellOption(shell);
+};
+
+export {
+  SCRIPT_SHELL_OPTIONS,
+  getScriptShellDefault,
+  resolveScriptShell,
+  validateScriptShellOption,
+};

package/src/runScript/subprocesses.d.ts

@@ -0,0 +1,11 @@
+/**Essentially a wrapper around `Bun.spawn` that ensures all
+ * the subprocess is killed when the main process exits for any
+ * handle-able exit code or signal. */
+export declare const createSubprocess: <
+  In extends Bun.SpawnOptions.Writable,
+  Out extends Bun.SpawnOptions.Readable,
+  Err extends Bun.SpawnOptions.Readable,
+>(
+  argv: string[],
+  options: Bun.Spawn.SpawnOptions<In, Out, Err>,
+) => Bun.Subprocess<In, Out, Err>;

package/src/runScript/subprocesses.mjs

@@ -0,0 +1,34 @@
+import { IS_WINDOWS, runOnExit } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/index.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../internal/logger/index.mjs"
+// CONCATENATED MODULE: ./src/runScript/subprocesses.ts
+
+const SUBPROCESS_REGISTRY = {};
+runOnExit((codeOrSignal) => {
+  Object.values(SUBPROCESS_REGISTRY).forEach((subprocess) => {
+    /**
+     * @todo Windows support for killing subprocesses is needed.
+     * subprocess.kill() will throw with not-implemented error
+     */ if (!subprocess.killed && subprocess.exitCode === null && !IS_WINDOWS) {
+      logger.debug(
+        `Killing subprocess ${subprocess.pid} with signal ${codeOrSignal}`,
+      );
+      subprocess.kill(codeOrSignal);
+    }
+  });
+});
+/**Essentially a wrapper around `Bun.spawn` that ensures all
+ * the subprocess is killed when the main process exits for any
+ * handle-able exit code or signal. */ const createSubprocess = (
+  argv,
+  options,
+) => {
+  const subprocess = Bun.spawn(argv, options);
+  SUBPROCESS_REGISTRY[subprocess.pid] = subprocess;
+  subprocess.exited.finally(() => {
+    delete SUBPROCESS_REGISTRY[subprocess.pid];
+  });
+  return subprocess;
+};
+
+export { createSubprocess };

package/src/workspaces/dependencyGraph/cycles.d.ts

@@ -0,0 +1,9 @@
+import type { Workspace } from "../workspace";
+export type DependencyCycleEdge = {
+  dependency: string;
+  dependent: string;
+};
+export declare const preventDependencyCycles: (workspaces: Workspace[]) => {
+  workspaces: Workspace[];
+  cycles: DependencyCycleEdge[];
+};

package/src/workspaces/dependencyGraph/cycles.mjs

@@ -0,0 +1,91 @@
+// CONCATENATED MODULE: ./src/workspaces/dependencyGraph/cycles.ts
+const preventDependencyCycles = (workspaces) => {
+  const byName = new Map(workspaces.map((n) => [n.name, n]));
+  // memo: name -> chains that end at `name`
+  const memo = new Map();
+  // recursion stack in order (root -> ... -> current)
+  const stack = [];
+  const inStack = new Set();
+  // dedupe cycle edges
+  const cyclesKeyed = new Map();
+  // all nodes that participate in at least one cycle
+  const cycleNodeSet = new Set();
+  const recordCycleEdge = (dependency, dependent) => {
+    const key = `${dependency}\u0000${dependent}`;
+    if (!cyclesKeyed.has(key))
+      cyclesKeyed.set(key, {
+        dependency,
+        dependent,
+      });
+  };
+  const chainsTo = (name) => {
+    const cached = memo.get(name);
+    if (cached) return cached;
+    stack.push(name);
+    inStack.add(name);
+    const node = byName.get(name);
+    const deps = node?.dependencies ?? [];
+    const result = [];
+    if (deps.length === 0) {
+      memo.set(name, result);
+      inStack.delete(name);
+      stack.pop();
+      return result;
+    }
+    for (const dep of deps) {
+      // Cycle edge: current `name` depends on `dep`, and `dep` is already in the active stack
+      if (inStack.has(dep)) {
+        recordCycleEdge(dep, name);
+        // Mark every node between `dep` and `name` (inclusive) as a cycle participant.
+        // `name` is already at stack[stack.length - 1] since it was pushed above.
+        const depIndex = stack.indexOf(dep);
+        for (let i = depIndex; i < stack.length; i++)
+          cycleNodeSet.add(stack[i]);
+        continue;
+      }
+      // Missing dependency name: treat as a leaf chain [dep, name]
+      if (!byName.has(dep)) {
+        result.push([dep, name]);
+        continue;
+      }
+      const depChains = chainsTo(dep);
+      if (depChains.length === 0) {
+        // dep is a leaf => base chain
+        result.push([dep, name]);
+      } else {
+        // extend each dep chain with current dependent
+        for (const c of depChains) result.push([...c, name]);
+      }
+    }
+    memo.set(name, result);
+    inStack.delete(name);
+    stack.pop();
+    return result;
+  };
+  workspaces.forEach((workspace) => {
+    chainsTo(workspace.name);
+  });
+  workspaces = workspaces.map((workspace) => ({
+    ...workspace,
+  }));
+  const cycles = [...cyclesKeyed.values()];
+  // Remove all dependency/dependent edges between workspaces that share a cycle.
+  // This leaves no opinionated "winner": if two workspaces are in the same cycle,
+  // all edges between them are stripped.
+  for (const workspace of workspaces) {
+    if (cycleNodeSet.has(workspace.name)) {
+      workspace.dependencies = workspace.dependencies.filter(
+        (d) => !cycleNodeSet.has(d),
+      );
+      workspace.dependents = workspace.dependents.filter(
+        (d) => !cycleNodeSet.has(d),
+      );
+    }
+  }
+  return {
+    workspaces,
+    cycles,
+  };
+};
+
+export { preventDependencyCycles };

package/src/workspaces/dependencyGraph/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./cycles";
+export * from "./resolveDependencies";

package/src/workspaces/dependencyGraph/index.mjs

@@ -0,0 +1,2 @@
+export * from "./cycles.mjs";
+export * from "./resolveDependencies.mjs"; // CONCATENATED MODULE: ./src/workspaces/dependencyGraph/index.ts

package/src/workspaces/dependencyGraph/resolveDependencies.d.ts

@@ -0,0 +1,18 @@
+import type { ResolvedWorkspaceConfig } from "../../config";
+import {
+  type BunCatalogSet,
+  type ResolvedPackageJsonContent,
+} from "../packageJson";
+import type { Workspace } from "../workspace";
+export type WorkspaceMap = {
+  [workspaceName: string]: {
+    workspace: Workspace;
+    config: ResolvedWorkspaceConfig;
+    packageJson: ResolvedPackageJsonContent;
+  };
+};
+export declare const resolveWorkspaceDependencies: (
+  workspaceMap: WorkspaceMap,
+  includeRootWorkspace: boolean,
+  catalogs?: BunCatalogSet,
+) => Workspace[];

package/src/workspaces/dependencyGraph/resolveDependencies.mjs

@@ -0,0 +1,52 @@
+import { resolveCatalogDependencyVersion } from "../packageJson.mjs"; // CONCATENATED MODULE: external "../packageJson.mjs"
+// CONCATENATED MODULE: ./src/workspaces/dependencyGraph/resolveDependencies.ts
+
+const resolveWorkspaceDependencies = (
+  workspaceMap,
+  includeRootWorkspace,
+  catalogs,
+) => {
+  const workspacePackages = Object.values(workspaceMap).filter(
+    ({ workspace }) => includeRootWorkspace || !workspace.isRoot,
+  );
+  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 resolvedVersion =
+            catalogs && dependencyVersion.startsWith("catalog:")
+              ? (resolveCatalogDependencyVersion(
+                  dependencyName,
+                  dependencyVersion,
+                  catalogs,
+                ) ?? dependencyVersion)
+              : dependencyVersion;
+          if (
+            resolvedVersion.startsWith("workspace:") &&
+            workspaceMap[dependencyName]
+          ) {
+            workspace.dependencies.push(dependencyName);
+            workspaceMap[dependencyName].workspace.dependents.push(
+              workspace.name,
+            );
+          }
+        }
+      }
+      return workspace;
+    },
+  );
+  return workspacesWithDependencies.map((workspace) => {
+    workspace.dependencies = [...new Set(workspace.dependencies)].sort();
+    workspace.dependents = [...new Set(workspace.dependents)].sort();
+    return workspace;
+  });
+};
+
+export { resolveWorkspaceDependencies };

package/src/workspaces/errors.d.ts

@@ -0,0 +1,13 @@
+export declare const WORKSPACE_ERRORS: import("../internal/core").DefinedErrors<
+  | "PackageNotFound"
+  | "InvalidPackageJson"
+  | "DuplicateWorkspaceName"
+  | "InvalidWorkspaceName"
+  | "NoWorkspaceName"
+  | "InvalidScripts"
+  | "InvalidWorkspaces"
+  | "InvalidWorkspacePattern"
+  | "AliasConflict"
+  | "AliasedWorkspaceNotFound"
+  | "RootWorkspaceNotFound"
+>;

package/src/workspaces/errors.mjs

@@ -0,0 +1,18 @@
+import { defineErrors } from "../internal/core/index.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/workspaces/errors.ts
+
+const WORKSPACE_ERRORS = defineErrors(
+  "PackageNotFound",
+  "InvalidPackageJson",
+  "DuplicateWorkspaceName",
+  "InvalidWorkspaceName",
+  "NoWorkspaceName",
+  "InvalidScripts",
+  "InvalidWorkspaces",
+  "InvalidWorkspacePattern",
+  "AliasConflict",
+  "AliasedWorkspaceNotFound",
+  "RootWorkspaceNotFound",
+);
+
+export { WORKSPACE_ERRORS };

package/src/workspaces/findWorkspaces.d.ts

@@ -0,0 +1,24 @@
+import { type WorkspaceMap } from "./dependencyGraph/resolveDependencies";
+import type { Workspace } from "./workspace";
+export interface FindWorkspacesOptions {
+  rootDirectory: string;
+  /** If provided, will override the workspaces found in the package.json. Mainly for testing purposes */
+  workspaceGlobs?: string[];
+  /** Whether to include the root workspace as a normal workspace.*/
+  includeRootWorkspace?: boolean;
+}
+export declare const sortWorkspaces: (workspaces: Workspace[]) => Workspace[];
+export declare const findWorkspaces: ({
+  rootDirectory,
+  workspaceGlobs: _workspaceGlobs,
+  includeRootWorkspace,
+}: FindWorkspacesOptions) => {
+  workspaces: Workspace[];
+  workspaceMap: WorkspaceMap;
+  rootWorkspace: Workspace;
+};
+export declare const validateWorkspaceAliases: (
+  workspaces: Workspace[],
+  workspaceAliases: Record<string, string>,
+  rootWorkspaceName: string,
+) => void;

package/src/workspaces/findWorkspaces.mjs

@@ -0,0 +1,217 @@
+import fs from "fs";
+import path from "path";
+import bun from "bun";
+import {
+  createDefaultWorkspaceConfig,
+  loadWorkspaceConfig,
+} from "../config/index.mjs";
+import { BUN_LOCK_ERRORS, readBunLockfile } from "../internal/bun/index.mjs";
+import { BunWorkspacesError } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/logger.mjs";
+import { resolveWorkspaceDependencies } from "./dependencyGraph/resolveDependencies.mjs";
+import { WORKSPACE_ERRORS } from "./errors.mjs";
+import {
+  resolvePackageJsonContent,
+  resolvePackageJsonPath,
+} from "./packageJson.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "bun"
+// CONCATENATED MODULE: external "../config/index.mjs"
+// CONCATENATED MODULE: external "../internal/bun/index.mjs"
+// CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../internal/logger/logger.mjs"
+// CONCATENATED MODULE: external "./dependencyGraph/resolveDependencies.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: external "./packageJson.mjs"
+// CONCATENATED MODULE: ./src/workspaces/findWorkspaces.ts
+
+const sortWorkspaces = (workspaces) =>
+  [...workspaces]
+    .sort((a, b) =>
+      a.isRoot
+        ? -1
+        : a.path.localeCompare(b.path) || a.name.localeCompare(b.name),
+    )
+    .reduce((acc, workspace, i, arr) => {
+      const previousWorkspace = arr[i - 1];
+      if (previousWorkspace && previousWorkspace.path === workspace.path) {
+        return acc;
+      }
+      return [...acc, workspace];
+    }, []);
+const getRootPackageJsonWorkspaceData = ({ rootDirectory }) => {
+  const packageJsonPath = path.join(rootDirectory, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new WORKSPACE_ERRORS.PackageNotFound(
+      `No package.json found for project root at ${packageJsonPath}`,
+    );
+  }
+  const { workspaces, catalog, catalogs } = resolvePackageJsonContent(
+    packageJsonPath,
+    rootDirectory,
+    ["workspaces"],
+  );
+  return {
+    workspaceGlobs: workspaces ?? [],
+    catalog,
+    catalogs,
+  };
+};
+const validateWorkspace = (workspace, workspaces) => {
+  if (workspaces.find((ws) => ws.path === workspace.path)) {
+    return false;
+  }
+  if (workspaces.find((ws) => ws.name === workspace.name)) {
+    throw new WORKSPACE_ERRORS.DuplicateWorkspaceName(
+      `Duplicate workspace name found: ${JSON.stringify(workspace.name)}`,
+    );
+  }
+  return true;
+};
+const findWorkspaces = ({
+  rootDirectory,
+  workspaceGlobs: _workspaceGlobs,
+  includeRootWorkspace = false,
+}) => {
+  rootDirectory = path.resolve(rootDirectory);
+  logger.debug(`Finding workspaces in ${rootDirectory}`);
+  let workspaces = [];
+  const workspaceMap = {};
+  logger.debug(`Reading bun.lock`);
+  const bunLock = readBunLockfile(rootDirectory);
+  if (bunLock instanceof BunWorkspacesError) {
+    if (bunLock instanceof BUN_LOCK_ERRORS.BunLockNotFound) {
+      bunLock.message =
+        `No bun.lock found at ${rootDirectory}. Check that this is the directory of your project and that you've ran 'bun install'.` +
+        " If you have ran 'bun install', you may simply have no workspaces or dependencies in your project.";
+    }
+    throw bunLock;
+  }
+  const { workspaceGlobs, catalog, catalogs } = _workspaceGlobs
+    ? {
+        workspaceGlobs: _workspaceGlobs,
+        catalog: {},
+        catalogs: {},
+      }
+    : getRootPackageJsonWorkspaceData({
+        rootDirectory,
+      });
+  const bunCatalogs = {
+    defaultCatalog: catalog,
+    namedCatalogs: catalogs,
+  };
+  let rootWorkspace;
+  const workspaceAliases = {};
+  for (const workspacePath of Object.keys(bunLock.workspaces).map((p) =>
+    path.join(rootDirectory, p),
+  )) {
+    const packageJsonPath = resolvePackageJsonPath(workspacePath);
+    if (packageJsonPath) {
+      const packageJsonContent = resolvePackageJsonContent(
+        packageJsonPath,
+        rootDirectory,
+        ["name", "scripts"],
+      );
+      const workspaceConfig = loadWorkspaceConfig(
+        path.dirname(packageJsonPath),
+      );
+      if (workspaceConfig) {
+        for (const alias of workspaceConfig.aliases) {
+          workspaceAliases[alias] = packageJsonContent.name;
+        }
+      }
+      const relativePath = path.relative(
+        rootDirectory,
+        path.dirname(packageJsonPath),
+      );
+      const matchPattern =
+        workspaceGlobs.find((glob) => new bun.Glob(glob).match(relativePath)) ??
+        "";
+      const isRootWorkspace = workspacePath === rootDirectory;
+      if (!matchPattern && !isRootWorkspace) {
+        logger.debug(`No match pattern found for ${relativePath}`);
+      }
+      const workspace = {
+        name: packageJsonContent.name ?? "",
+        isRoot: isRootWorkspace,
+        matchPattern: workspacePath === rootDirectory ? "" : matchPattern,
+        path: path.relative(rootDirectory, path.dirname(packageJsonPath)),
+        scripts: Object.keys(packageJsonContent.scripts ?? {}).sort(),
+        aliases: [
+          ...new Set(
+            Object.entries(workspaceAliases ?? {})
+              .filter(([_, value]) => value === packageJsonContent.name)
+              .map(([key]) => key)
+              .concat(workspaceConfig?.aliases ?? []),
+          ),
+        ],
+        dependencies: [],
+        dependents: [],
+      };
+      if (workspace.isRoot) {
+        logger.debug(`Found root workspace: ${workspace.name}`);
+        rootWorkspace = workspace;
+      }
+      if (validateWorkspace(workspace, workspaces)) {
+        if (!workspace.isRoot || includeRootWorkspace) {
+          workspaces.push(workspace);
+        }
+        workspaceMap[workspace.name] = {
+          workspace,
+          config: workspaceConfig ?? createDefaultWorkspaceConfig(),
+          packageJson: packageJsonContent,
+        };
+      }
+    }
+  }
+  if (!rootWorkspace) {
+    throw new WORKSPACE_ERRORS.RootWorkspaceNotFound("No root workspace found");
+  }
+  workspaces = sortWorkspaces(
+    resolveWorkspaceDependencies(
+      workspaceMap,
+      includeRootWorkspace,
+      bunCatalogs,
+    ),
+  );
+  validateWorkspaceAliases(workspaces, workspaceAliases, rootWorkspace.name);
+  logger.debug(
+    `Found ${workspaces.length} workspaces: ${workspaces.map((ws) => ws.name).join(", ")}`,
+  );
+  return {
+    workspaces,
+    workspaceMap,
+    rootWorkspace,
+  };
+};
+const validateWorkspaceAliases = (
+  workspaces,
+  workspaceAliases,
+  rootWorkspaceName,
+) => {
+  for (const [alias, name] of Object.entries(workspaceAliases ?? {})) {
+    if (workspaces.find((ws) => ws.name === alias)) {
+      throw new WORKSPACE_ERRORS.AliasConflict(
+        `Alias ${JSON.stringify(alias)} conflicts with workspace name ${JSON.stringify(name)}`,
+      );
+    }
+    const workspaceWithDuplicateAlias = workspaces.find(
+      (ws) => ws.name !== name && ws.aliases.includes(alias),
+    );
+    if (workspaceWithDuplicateAlias) {
+      throw new WORKSPACE_ERRORS.AliasConflict(
+        `Workspaces ${JSON.stringify(name)} and ${JSON.stringify(workspaceWithDuplicateAlias.name)} have the same alias ${JSON.stringify(alias)}`,
+      );
+    }
+    if (
+      !workspaces.find((ws) => ws.name === name) &&
+      name !== rootWorkspaceName
+    ) {
+      throw new WORKSPACE_ERRORS.AliasedWorkspaceNotFound(
+        `Workspace ${JSON.stringify(name)} was aliased by ${JSON.stringify(alias)} but was not found`,
+      );
+    }
+  }
+};
+
+export { findWorkspaces, sortWorkspaces, validateWorkspaceAliases };

package/src/workspaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./findWorkspaces";
+export * from "./packageJson";
+export * from "./errors";
+export type * from "./workspace";

package/src/workspaces/index.mjs

@@ -0,0 +1,3 @@
+export * from "./findWorkspaces.mjs";
+export * from "./packageJson.mjs";
+export * from "./errors.mjs"; // CONCATENATED MODULE: ./src/workspaces/index.ts

package/src/workspaces/packageJson.d.ts

@@ -0,0 +1,31 @@
+export declare const resolvePackageJsonPath: (directoryItem: string) => string;
+export type BunCatalog = Record<string, string>;
+export type BunCatalogSet = {
+  defaultCatalog: BunCatalog;
+  namedCatalogs: Record<string, BunCatalog>;
+};
+export type ResolvedPackageJsonContent = {
+  name: string;
+  workspaces: string[];
+  catalog: BunCatalog;
+  catalogs: Record<string, BunCatalog>;
+  scripts: Record<string, string>;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
+  optionalDependencies: Record<string, string>;
+} & Record<string, unknown>;
+/**
+ * Resolve a `catalog:` or `catalog:name` version reference for a given package name.
+ * Returns the resolved version string, or null if the catalog or package is not found.
+ */
+export declare const resolveCatalogDependencyVersion: (
+  packageName: string,
+  catalogRef: string,
+  catalogs: BunCatalogSet,
+) => string | null;
+export declare const resolvePackageJsonContent: (
+  packageJsonPath: string,
+  rootDirectory: string,
+  validations: ("workspaces" | "name" | "scripts")[],
+) => ResolvedPackageJsonContent;