bun-workspaces 1.0.0-alpha.8 → 1.0.0

package/src/runScript/scriptRuntimeMetadata.d.ts

@@ -0,0 +1,73 @@
+import type { ScriptShellOption } from "./scriptShellOption";
+export interface ScriptRuntimeMetadata {
+  projectPath: string;
+  projectName: string;
+  workspacePath: string;
+  workspaceRelativePath: string;
+  workspaceName: string;
+  scriptName: string;
+}
+declare const SCRIPT_RUNTIME_METADATA_CONFIG: {
+  readonly projectPath: {
+    readonly inlineName: "<projectPath>";
+    readonly envVarName: "BW_PROJECT_PATH";
+  };
+  readonly projectName: {
+    readonly inlineName: "<projectName>";
+    readonly envVarName: "BW_PROJECT_NAME";
+  };
+  readonly workspacePath: {
+    readonly inlineName: "<workspacePath>";
+    readonly envVarName: "BW_WORKSPACE_PATH";
+  };
+  readonly workspaceRelativePath: {
+    readonly inlineName: "<workspaceRelativePath>";
+    readonly envVarName: "BW_WORKSPACE_RELATIVE_PATH";
+  };
+  readonly scriptName: {
+    readonly inlineName: "<scriptName>";
+    readonly envVarName: "BW_SCRIPT_NAME";
+  };
+  readonly workspaceName: {
+    readonly inlineName: "<workspaceName>";
+    readonly envVarName: "BW_WORKSPACE_NAME";
+  };
+};
+export type ScriptRuntimeMetadataKey =
+  keyof typeof SCRIPT_RUNTIME_METADATA_CONFIG;
+export declare const getScriptRuntimeMetadataConfig: (
+  key: ScriptRuntimeMetadataKey,
+) =>
+  | {
+      readonly inlineName: "<projectPath>";
+      readonly envVarName: "BW_PROJECT_PATH";
+    }
+  | {
+      readonly inlineName: "<projectName>";
+      readonly envVarName: "BW_PROJECT_NAME";
+    }
+  | {
+      readonly inlineName: "<workspacePath>";
+      readonly envVarName: "BW_WORKSPACE_PATH";
+    }
+  | {
+      readonly inlineName: "<workspaceRelativePath>";
+      readonly envVarName: "BW_WORKSPACE_RELATIVE_PATH";
+    }
+  | {
+      readonly inlineName: "<scriptName>";
+      readonly envVarName: "BW_SCRIPT_NAME";
+    }
+  | {
+      readonly inlineName: "<workspaceName>";
+      readonly envVarName: "BW_WORKSPACE_NAME";
+    };
+export declare const createScriptRuntimeEnvVars: (
+  metadata: ScriptRuntimeMetadata,
+) => Record<string, string>;
+export declare const interpolateScriptRuntimeMetadata: (
+  text: string,
+  metadata: ScriptRuntimeMetadata,
+  shell: ScriptShellOption,
+) => string;
+export {};

package/src/runScript/scriptRuntimeMetadata.mjs

@@ -0,0 +1,61 @@
+import { IS_WINDOWS } from "../internal/core/index.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/runScript/scriptRuntimeMetadata.ts
+
+const SCRIPT_RUNTIME_METADATA_CONFIG = {
+  projectPath: {
+    inlineName: "<projectPath>",
+    envVarName: "BW_PROJECT_PATH",
+  },
+  projectName: {
+    inlineName: "<projectName>",
+    envVarName: "BW_PROJECT_NAME",
+  },
+  workspacePath: {
+    inlineName: "<workspacePath>",
+    envVarName: "BW_WORKSPACE_PATH",
+  },
+  workspaceRelativePath: {
+    inlineName: "<workspaceRelativePath>",
+    envVarName: "BW_WORKSPACE_RELATIVE_PATH",
+  },
+  scriptName: {
+    inlineName: "<scriptName>",
+    envVarName: "BW_SCRIPT_NAME",
+  },
+  workspaceName: {
+    inlineName: "<workspaceName>",
+    envVarName: "BW_WORKSPACE_NAME",
+  },
+};
+const getScriptRuntimeMetadataConfig = (key) =>
+  SCRIPT_RUNTIME_METADATA_CONFIG[key];
+const createScriptRuntimeEnvVars = (metadata) =>
+  Object.entries(SCRIPT_RUNTIME_METADATA_CONFIG).reduce((acc, [key, value]) => {
+    acc[value.envVarName] = metadata[key];
+    return acc;
+  }, {});
+const interpolateScriptRuntimeMetadata = (text, metadata, shell) =>
+  text.replace(
+    new RegExp(
+      Object.values(SCRIPT_RUNTIME_METADATA_CONFIG)
+        .flatMap((value) => value.inlineName)
+        .join("|"),
+      "g",
+    ),
+    (match) => {
+      const key = Object.entries(SCRIPT_RUNTIME_METADATA_CONFIG).find(
+        ([_, value]) => value.inlineName === match,
+      )?.[0];
+      const value = metadata[key];
+      if (IS_WINDOWS && shell === "bun") {
+        return value.replace(/\\/g, "\\\\");
+      }
+      return value;
+    },
+  );
+
+export {
+  createScriptRuntimeEnvVars,
+  getScriptRuntimeMetadataConfig,
+  interpolateScriptRuntimeMetadata,
+};

package/src/runScript/scriptShellOption.d.ts

@@ -0,0 +1,8 @@
+export declare const SCRIPT_SHELL_OPTIONS: readonly ["bun", "system"];
+export type ScriptShellOption = (typeof SCRIPT_SHELL_OPTIONS)[number];
+export declare const validateScriptShellOption: (
+  shell: string,
+  fromEnvVar?: boolean,
+) => ScriptShellOption;
+export declare const getScriptShellDefault: () => "bun" | "system";
+export declare const resolveScriptShell: (shell?: string) => ScriptShellOption;

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

@@ -1 +1,13 @@
-export declare const ERRORS: import("../internal/error").DefinedErrors<"PackageNotFound" | "InvalidPackageJson" | "DuplicateWorkspaceName" | "InvalidWorkspaceName" | "NoWorkspaceName" | "InvalidScripts" | "InvalidWorkspaces" | "InvalidWorkspacePattern" | "AliasConflict" | "AliasedWorkspaceNotFound">;
+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

@@ -1,3 +1,18 @@
-import { defineErrors } from "../internal/error.mjs";
-const ERRORS = defineErrors("PackageNotFound", "InvalidPackageJson", "DuplicateWorkspaceName", "InvalidWorkspaceName", "NoWorkspaceName", "InvalidScripts", "InvalidWorkspaces", "InvalidWorkspacePattern", "AliasConflict", "AliasedWorkspaceNotFound");
-export { ERRORS };
+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

@@ -1,17 +1,24 @@
-import type { ProjectConfig } from "../config";
+import { type WorkspaceMap } from "./dependencyGraph/resolveDependencies";
 import type { Workspace } from "./workspace";
 export interface FindWorkspacesOptions {
-    rootDir: string;
-    workspaceGlobs: string[];
-    workspaceAliases?: ProjectConfig["workspaceAliases"];
+  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 findWorkspaces: ({ rootDir, workspaceGlobs, workspaceAliases, }: FindWorkspacesOptions) => {
-    workspaces: Workspace[];
-};
-export declare const validateWorkspaceAliases: (workspaces: Workspace[], workspaceAliases: ProjectConfig["workspaceAliases"]) => void;
-export declare const findWorkspacesFromPackage: ({ rootDir, workspaceAliases, }: ProjectConfig & {
-    rootDir: string;
-}) => {
-    name: string;
-    workspaces: Workspace[];
+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;