bun-workspaces 1.0.0-alpha.8 → 1.0.0

package/src/runScript/parallel.mjs

@@ -0,0 +1,56 @@
+import os from "os";
+import {
+  getUserEnvVar,
+  getUserEnvVarName,
+} from "../config/userEnvVars/index.mjs";
+import { BunWorkspacesError } from "../internal/core/index.mjs"; // CONCATENATED MODULE: external "os"
+// CONCATENATED MODULE: external "../config/userEnvVars/index.mjs"
+// CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/runScript/parallel.ts
+
+const PARALLEL_MAX_VALUES = ["auto", "unbounded", "default"];
+/** Should always return at least 1 */ const determineParallelMax = (
+  value,
+  errorMessageSuffix = "",
+) => {
+  if (!isNaN(Number(value))) {
+    value = Math.floor(Number(value));
+  }
+  if (typeof value === "number") {
+    if (value < 1 || isNaN(value)) {
+      throw new BunWorkspacesError(
+        `Parallel max value must be at least 1${errorMessageSuffix}`,
+      );
+    }
+    return Math.floor(value);
+  }
+  if (value === "default") {
+    const defaultMax = getUserEnvVar("parallelMaxDefault")?.trim();
+    if (defaultMax === "default") return determineParallelMax("auto");
+    return determineParallelMax(
+      defaultMax ?? "auto",
+      ` (set by env var ${getUserEnvVarName("parallelMaxDefault")})`,
+    );
+  }
+  if (value === "unbounded") {
+    return Infinity;
+  }
+  const cpuCount = Math.max(1, os.availableParallelism());
+  if (value === "auto") {
+    return cpuCount;
+  }
+  if (value.endsWith("%")) {
+    const percentage = parseFloat(value.slice(0, -1));
+    if (isNaN(percentage) || percentage <= 0 || percentage > 100) {
+      throw new BunWorkspacesError(
+        `Parallel max value must be a number greater than 0 and less than or equal to 100${errorMessageSuffix}`,
+      );
+    }
+    return Math.max(1, Math.floor((cpuCount * percentage) / 100));
+  }
+  throw new BunWorkspacesError(
+    `Invalid parallel max value: ${JSON.stringify(value)}${errorMessageSuffix}`,
+  );
+};
+
+export { PARALLEL_MAX_VALUES, determineParallelMax };

package/src/runScript/recursion.d.ts

@@ -0,0 +1,4 @@
+export declare const checkIsRecursiveScript: (
+  workspaceName: string,
+  scriptName: string,
+) => boolean | undefined;

package/src/runScript/recursion.mjs

@@ -0,0 +1,17 @@
+import { getScriptRuntimeMetadataConfig } from "./scriptRuntimeMetadata.mjs"; // CONCATENATED MODULE: external "./scriptRuntimeMetadata.mjs"
+// CONCATENATED MODULE: ./src/runScript/recursion.ts
+
+const checkIsRecursiveScript = (workspaceName, scriptName) => {
+  const parentWorkspace =
+    process.env[getScriptRuntimeMetadataConfig("workspaceName").envVarName];
+  const parentScript =
+    process.env[getScriptRuntimeMetadataConfig("scriptName").envVarName];
+  if (!parentWorkspace || !parentScript) {
+    return false;
+  }
+  if (parentWorkspace === workspaceName && parentScript === scriptName) {
+    return true;
+  }
+};
+
+export { checkIsRecursiveScript };

package/src/runScript/runScript.d.ts

@@ -0,0 +1,45 @@
+import { type MultiProcessOutput, type OutputStreamName } from "./output";
+import type { ScriptCommand } from "./scriptCommand";
+import type { ScriptShellOption } from "./scriptShellOption";
+export type RunScriptExit<ScriptMetadata extends object = object> = {
+  exitCode: number;
+  signal: NodeJS.Signals | null;
+  success: boolean;
+  /** Whether the script was skipped due to a failed dependency */
+  skipped?: boolean;
+  startTimeISO: string;
+  endTimeISO: string;
+  durationMs: number;
+  metadata: ScriptMetadata;
+};
+export type RunScriptResult<ScriptMetadata extends object = object> = {
+  output: MultiProcessOutput<
+    ScriptMetadata & {
+      streamName: OutputStreamName;
+    }
+  >;
+  exit: Promise<RunScriptExit<ScriptMetadata>>;
+  metadata: ScriptMetadata;
+  kill: (exit?: number | NodeJS.Signals) => void;
+};
+export type RunScriptOptions<ScriptMetadata extends object = object> = {
+  scriptCommand: ScriptCommand;
+  metadata: ScriptMetadata;
+  env: Record<string, string>;
+  /** The shell to use to run the script. Defaults to "system". */
+  shell?: ScriptShellOption;
+  /** Set to `true` to ignore all output from the script. This saves memory when you don't need script output. */
+  ignoreOutput?: boolean;
+};
+/**
+ * Run some script and get an async output stream of
+ * stdout and stderr chunks and a result object
+ * containing exit details.
+ */
+export declare const runScript: <ScriptMetadata extends object = object>({
+  scriptCommand,
+  metadata,
+  env,
+  shell,
+  ignoreOutput,
+}: RunScriptOptions<ScriptMetadata>) => RunScriptResult<ScriptMetadata>;

package/src/runScript/runScript.mjs

@@ -0,0 +1,89 @@
+import {
+  createMultiProcessOutput,
+  createProcessOutput,
+} from "./output/index.mjs";
+import { createScriptExecutor } from "./scriptExecution.mjs";
+import { createSubprocess } from "./subprocesses.mjs"; // CONCATENATED MODULE: external "./output/index.mjs"
+// CONCATENATED MODULE: external "./scriptExecution.mjs"
+// CONCATENATED MODULE: external "./subprocesses.mjs"
+// CONCATENATED MODULE: ./src/runScript/runScript.ts
+
+const SIGNAL_MAP = {
+  130: "SIGINT",
+  143: "SIGTERM",
+  129: "SIGHUP",
+  131: "SIGQUIT",
+  138: "SIGUSR1",
+  140: "SIGUSR2",
+};
+/**
+ * Run some script and get an async output stream of
+ * stdout and stderr chunks and a result object
+ * containing exit details.
+ */ const runScript = ({
+  scriptCommand,
+  metadata,
+  env,
+  shell = "system",
+  ignoreOutput = false,
+}) => {
+  const startTime = new Date();
+  const { argv, cleanup } = createScriptExecutor(scriptCommand.command, shell);
+  const proc = createSubprocess(argv, {
+    cwd: scriptCommand.workingDirectory || process.cwd(),
+    env: {
+      ...process.env,
+      ...env,
+      _BW_SCRIPT_SHELL_OPTION: shell,
+      FORCE_COLOR: "1",
+    },
+    stdout: ignoreOutput ? "ignore" : "pipe",
+    stderr: ignoreOutput ? "ignore" : "pipe",
+    stdin: "ignore",
+  });
+  proc.exited.finally(cleanup);
+  const processOutput = createMultiProcessOutput([
+    createProcessOutput(
+      proc.stdout
+        ? proc.stdout
+        : (async function* () {
+            /* empty */
+          })(),
+      {
+        ...metadata,
+        streamName: "stdout",
+      },
+    ),
+    createProcessOutput(
+      proc.stderr
+        ? proc.stderr
+        : (async function* () {
+            /* empty */
+          })(),
+      {
+        ...metadata,
+        streamName: "stderr",
+      },
+    ),
+  ]);
+  const exit = proc.exited.then((exitCode) => {
+    const endTime = new Date();
+    return {
+      exitCode,
+      signal: proc.signalCode ?? SIGNAL_MAP[exitCode] ?? null,
+      success: exitCode === 0,
+      startTimeISO: startTime.toISOString(),
+      endTimeISO: endTime.toISOString(),
+      durationMs: endTime.getTime() - startTime.getTime(),
+      metadata,
+    };
+  });
+  return {
+    output: processOutput,
+    exit,
+    metadata,
+    kill: (exit) => proc.kill(exit),
+  };
+};
+
+export { runScript };

package/src/runScript/runScripts.d.ts

@@ -0,0 +1,65 @@
+import { type MultiProcessOutput, type OutputStreamName } from "./output";
+import { type ParallelMaxValue } from "./parallel";
+import { type RunScriptExit, type RunScriptResult } from "./runScript";
+import { type ScriptCommand } from "./scriptCommand";
+import { type ScriptShellOption } from "./scriptShellOption";
+export type RunScriptsScript<ScriptMetadata extends object = object> = {
+  scriptCommand: ScriptCommand;
+  metadata: ScriptMetadata;
+  env: Record<string, string>;
+  /** The shell to use to run the script */
+  shell?: ScriptShellOption;
+  /** Indices of other scripts in the array that must complete before this one starts */
+  dependsOn?: number[];
+  /** Set to `true` to ignore all output from the script. This saves memory when you don't need script output. */
+  ignoreOutput?: boolean;
+};
+export type RunScriptsScriptResult<ScriptMetadata extends object = object> = {
+  /** The result of running the script */
+  result: RunScriptResult<ScriptMetadata>;
+};
+export type RunScriptsSummary<ScriptMetadata extends object = object> = {
+  totalCount: number;
+  successCount: number;
+  failureCount: number;
+  allSuccess: boolean;
+  startTimeISO: string;
+  endTimeISO: string;
+  durationMs: number;
+  scriptResults: RunScriptExit<ScriptMetadata>[];
+};
+export type ScriptEventName = "start" | "skip" | "exit";
+export type RunScriptsResult<ScriptMetadata extends object = object> = {
+  output: MultiProcessOutput<
+    ScriptMetadata & {
+      streamName: OutputStreamName;
+    }
+  >;
+  /** Resolves with a results summary after all scripts have exited */
+  summary: Promise<RunScriptsSummary<ScriptMetadata>>;
+};
+export type RunScriptsParallelOptions = {
+  max: ParallelMaxValue;
+};
+export type RunScriptsOptions<ScriptMetadata extends object = object> = {
+  scripts: RunScriptsScript<ScriptMetadata>[];
+  parallel: boolean | RunScriptsParallelOptions;
+  /** When true, run scripts even if a dependency failed. Default: false (skip them). */
+  ignoreDependencyFailure?: boolean;
+  /** Set to `true` to ignore all output from the scripts. This saves memory when you don't need script output. */
+  ignoreOutput?: boolean;
+  /** Callback to invoke when a script event occurs */
+  onScriptEvent?: (
+    event: ScriptEventName,
+    scriptIndex: number,
+    result: RunScriptExit<ScriptMetadata> | null,
+  ) => void;
+};
+/** Run a list of scripts */
+export declare const runScripts: <ScriptMetadata extends object = object>({
+  scripts,
+  parallel,
+  ignoreDependencyFailure,
+  ignoreOutput,
+  onScriptEvent,
+}: RunScriptsOptions<ScriptMetadata>) => RunScriptsResult<ScriptMetadata>;

package/src/runScript/runScripts.mjs

@@ -0,0 +1,263 @@
+import { createAsyncIterableQueue } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/index.mjs";
+import {
+  createMultiProcessOutput,
+  createProcessOutput,
+} from "./output/index.mjs";
+import { determineParallelMax } from "./parallel.mjs";
+import { runScript } from "./runScript.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./output/index.mjs"
+// CONCATENATED MODULE: external "./parallel.mjs"
+// CONCATENATED MODULE: external "./runScript.mjs"
+// CONCATENATED MODULE: ./src/runScript/runScripts.ts
+
+/** Validate dependency indices and detect cycles via DFS */ const validateScriptDependencies =
+  (scripts) => {
+    const scriptCount = scripts.length;
+    for (let i = 0; i < scriptCount; i++) {
+      const deps = scripts[i].dependsOn;
+      if (!deps) continue;
+      for (const dep of deps) {
+        if (dep === i) {
+          throw new Error(
+            `Script at index ${i} has a self-referencing dependency`,
+          );
+        }
+        if (dep < 0 || dep >= scriptCount) {
+          throw new Error(
+            `Script at index ${i} depends on invalid index ${dep} (valid range: 0-${scriptCount - 1})`,
+          );
+        }
+      }
+    }
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const colors = new Array(scriptCount).fill(WHITE);
+    const visit = (node, path) => {
+      colors[node] = GRAY;
+      const deps = scripts[node].dependsOn;
+      if (deps) {
+        for (const dep of deps) {
+          if (colors[dep] === GRAY) {
+            const cycleStart = path.indexOf(dep);
+            const cycle = path.slice(cycleStart);
+            throw new Error(
+              `Dependency cycle detected: ${[...cycle, dep].join(" -> ")}`,
+            );
+          }
+          if (colors[dep] === WHITE) {
+            visit(dep, [...path, dep]);
+          }
+        }
+      }
+      colors[node] = BLACK;
+    };
+    for (let i = 0; i < scriptCount; i++) {
+      if (colors[i] === WHITE) {
+        visit(i, [i]);
+      }
+    }
+  };
+/** Run a list of scripts */ const runScripts = ({
+  scripts,
+  parallel,
+  ignoreDependencyFailure = false,
+  ignoreOutput = false,
+  onScriptEvent,
+}) => {
+  validateScriptDependencies(scripts);
+  const startTime = new Date();
+  const scriptTriggers = scripts.map((_, index) => {
+    let trigger = () => {
+      void 0;
+    };
+    const promise = new Promise((res) => {
+      trigger = () => res(result);
+    });
+    const result = {
+      promise,
+      trigger,
+      index,
+    };
+    return result;
+  });
+  const scriptResults = scripts.map(() => null);
+  const parallelMax =
+    parallel === false
+      ? 1
+      : determineParallelMax(
+          typeof parallel === "boolean" ? "default" : parallel.max,
+        );
+  const parallelBatchSize = Math.min(parallelMax, scripts.length);
+  const recommendedParallelMax = determineParallelMax("auto");
+  if (
+    parallel &&
+    parallelBatchSize > recommendedParallelMax &&
+    process.env._BW_IS_INTERNAL_TEST !== "true"
+  ) {
+    logger.warn(
+      `Number of scripts to run in parallel (${parallelBatchSize}) is greater than the available CPUs (${recommendedParallelMax})`,
+    );
+  }
+  const pendingScripts = new Set(scripts.map((_, i) => i));
+  const runningScripts = new Set();
+  const completedScripts = new Set();
+  const exitResults = scripts.map(() => null);
+  const scriptProcessBytes = scripts.map(() => null);
+  const createSkippedExit = (index) => {
+    const now = new Date().toISOString();
+    return {
+      exitCode: -1,
+      signal: null,
+      success: false,
+      skipped: true,
+      startTimeISO: now,
+      endTimeISO: now,
+      durationMs: 0,
+      metadata: scripts[index].metadata,
+    };
+  };
+  const createSkippedResult = (index) => {
+    const skippedExit = createSkippedExit(index);
+    exitResults[index] = skippedExit;
+    return {
+      result: {
+        output: createMultiProcessOutput([]),
+        exit: Promise.resolve(skippedExit),
+        metadata: scripts[index].metadata,
+        kill: () => {
+          /* empty */
+        },
+      },
+    };
+  };
+  const hasDependencyFailure = (index) => {
+    const deps = scripts[index].dependsOn;
+    if (!deps) return false;
+    return deps.some(
+      (dep) => exitResults[dep] !== null && !exitResults[dep].success,
+    );
+  };
+  const areDependenciesMet = (index) => {
+    const deps = scripts[index].dependsOn;
+    if (!deps) return true;
+    return deps.every((dep) => completedScripts.has(dep));
+  };
+  const scriptOutputQueues = scripts.map(() => ({
+    stdout: createAsyncIterableQueue(),
+    stderr: createAsyncIterableQueue(),
+  }));
+  const scheduleReadyScripts = () => {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const index of [...pendingScripts]) {
+        if (runningScripts.size >= parallelMax) return;
+        if (!areDependenciesMet(index)) continue;
+        if (!ignoreDependencyFailure && hasDependencyFailure(index)) {
+          pendingScripts.delete(index);
+          completedScripts.add(index);
+          scriptResults[index] = createSkippedResult(index);
+          scriptProcessBytes[index] = (async function* () {
+            /* empty */
+          })();
+          scriptOutputQueues[index].stdout.close();
+          scriptOutputQueues[index].stderr.close();
+          onScriptEvent?.("skip", index, null);
+          scriptTriggers[index].trigger();
+          changed = true;
+          continue;
+        }
+        pendingScripts.delete(index);
+        runningScripts.add(index);
+        const scriptResult = {
+          ...scripts[index],
+          result: runScript({
+            ...scripts[index],
+            env: {
+              ...scripts[index].env,
+              _BW_PARALLEL_MAX: parallelMax.toString(),
+            },
+            ignoreOutput,
+          }),
+        };
+        scriptResults[index] = scriptResult;
+        const bytesOutput = scriptResult.result.output.bytes();
+        scriptProcessBytes[index] = bytesOutput;
+        (async () => {
+          for await (const { chunk, metadata } of bytesOutput) {
+            scriptOutputQueues[index][metadata.streamName].push(chunk);
+          }
+          scriptOutputQueues[index].stdout.close();
+          scriptOutputQueues[index].stderr.close();
+        })();
+        onScriptEvent?.("start", index, null);
+        scriptTriggers[index].trigger();
+        scriptResult.result.exit.then((exit) => {
+          runningScripts.delete(index);
+          completedScripts.add(index);
+          exitResults[index] = exit;
+          onScriptEvent?.("exit", index, exit);
+          scheduleReadyScripts();
+        });
+      }
+    }
+  };
+  const multiProcessOutput = createMultiProcessOutput(
+    scriptOutputQueues.flatMap(({ stdout, stderr }, index) => [
+      createProcessOutput(stdout, {
+        ...scripts[index].metadata,
+        streamName: "stdout",
+      }),
+      createProcessOutput(stderr, {
+        ...scripts[index].metadata,
+        streamName: "stderr",
+      }),
+    ]),
+  );
+  const handleScriptProcesses = async () => {
+    let pendingScriptCount = scripts.length;
+    while (pendingScriptCount > 0) {
+      const { index } = await Promise.race(
+        scriptTriggers.map((trigger) => trigger.promise),
+      );
+      pendingScriptCount--;
+      scriptTriggers[index].promise = new Promise(() => {
+        void 0;
+      });
+    }
+    await Promise.all(
+      scriptOutputQueues.flatMap(({ stdout, stderr }) => [
+        stdout.closed,
+        stderr.closed,
+      ]),
+    );
+    await Promise.all(scriptResults.map(({ result }) => result.exit));
+  };
+  const awaitSummary = async () => {
+    scheduleReadyScripts();
+    await handleScriptProcesses();
+    const scriptExitResults = await Promise.all(
+      scripts.map((_, index) => scriptResults[index].result.exit),
+    );
+    const endTime = new Date();
+    return {
+      totalCount: scriptExitResults.length,
+      successCount: scriptExitResults.filter((exit) => exit.success).length,
+      failureCount: scriptExitResults.filter((exit) => !exit.success).length,
+      allSuccess: scriptExitResults.every((exit) => exit.success),
+      startTimeISO: startTime.toISOString(),
+      endTimeISO: endTime.toISOString(),
+      durationMs: endTime.getTime() - startTime.getTime(),
+      scriptResults: scriptExitResults,
+    };
+  };
+  return {
+    output: multiProcessOutput,
+    summary: awaitSummary(),
+  };
+};
+
+export { runScripts };

package/src/runScript/scriptCommand.d.ts

@@ -0,0 +1,33 @@
+import type { Workspace } from "../workspaces";
+export declare const WORKSPACE_SCRIPT_COMMAND_METHODS: readonly [
+  "cd",
+  "filter",
+];
+export type WorkspaceScriptCommandMethod =
+  (typeof WORKSPACE_SCRIPT_COMMAND_METHODS)[number];
+/** Basic metadata to run a script, the command string and the directory to run it in */
+export interface ScriptCommand {
+  /** The command string to run */
+  command: string;
+  /** The directory to run the command in */
+  workingDirectory: string;
+}
+export interface CreateWorkspaceScriptCommandOptions {
+  /**
+   * The method to use to run the script.
+   * Either run in the workspace directory or use bun's --filter option.
+   * Defaults to "cd".
+   */
+  method?: WorkspaceScriptCommandMethod;
+  /** The name of the script to run */
+  scriptName: string;
+  /** The arguments to append to the command */
+  args: string;
+  /** The workspace that the script belongs to */
+  workspace: Workspace;
+  /** The root directory of the project */
+  rootDirectory: string;
+}
+export declare const createWorkspaceScriptCommand: (
+  options: CreateWorkspaceScriptCommandOptions,
+) => ScriptCommand;

package/src/runScript/scriptCommand.mjs

@@ -0,0 +1,19 @@
+import path from "path"; // CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: ./src/runScript/scriptCommand.ts
+
+const WORKSPACE_SCRIPT_COMMAND_METHODS = ["cd", "filter"];
+const spaceArgs = (args) => (args ? ` ${args.trim()}` : "");
+const METHODS = {
+  cd: ({ scriptName, workspace, rootDirectory, args }) => ({
+    workingDirectory: path.resolve(rootDirectory, workspace.path),
+    command: `bun --silent run ${scriptName}${spaceArgs(args)}`,
+  }),
+  filter: ({ scriptName, workspace, args, rootDirectory }) => ({
+    workingDirectory: rootDirectory,
+    command: `bun --silent run --filter=${JSON.stringify(workspace.name)} ${scriptName}${spaceArgs(args)}`,
+  }),
+};
+const createWorkspaceScriptCommand = (options) =>
+  METHODS[options.method ?? "cd"](options);
+
+export { WORKSPACE_SCRIPT_COMMAND_METHODS, createWorkspaceScriptCommand };

package/src/runScript/scriptExecution.d.ts

@@ -0,0 +1,9 @@
+import { type ScriptShellOption } from "./scriptShellOption";
+export type ScriptExecutor = {
+  argv: string[];
+  cleanup: () => void;
+};
+export declare const createScriptExecutor: (
+  command: string,
+  shell: ScriptShellOption,
+) => ScriptExecutor;

package/src/runScript/scriptExecution.mjs

@@ -0,0 +1,50 @@
+import {
+  BunWorkspacesError,
+  DEFAULT_TEMP_DIR,
+  IS_WINDOWS,
+  createShortId,
+} from "../internal/core/index.mjs";
+import { resolveScriptShell } from "./scriptShellOption.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "./scriptShellOption.mjs"
+// CONCATENATED MODULE: ./src/runScript/scriptExecution.ts
+
+const createWindowsBatchFile = (command) => {
+  const fileName = `${createShortId(6)}.cmd`;
+  const fileContent = `@echo off\r\n${command}\r\n`;
+  return DEFAULT_TEMP_DIR.createFile({
+    name: fileName,
+    content: fileContent,
+  });
+};
+const createShellScript = (command) => {
+  const fileName = `${createShortId(6)}.sh`;
+  return DEFAULT_TEMP_DIR.createFile({
+    name: fileName,
+    content: command,
+    mode: 493,
+  });
+};
+const createScriptExecutor = (command, shell) => {
+  shell = resolveScriptShell(shell);
+  if (shell === "bun") {
+    const { filePath, cleanup } = createShellScript(command);
+    return {
+      argv: ["bun", filePath],
+      cleanup,
+    };
+  }
+  if (shell === "system") {
+    const { filePath, cleanup } = IS_WINDOWS
+      ? createWindowsBatchFile(command)
+      : createShellScript(command);
+    return {
+      argv: IS_WINDOWS
+        ? ["cmd", "/d", "/s", "/c", "call", filePath]
+        : ["sh", "-c", filePath],
+      cleanup,
+    };
+  }
+  throw new BunWorkspacesError(`Invalid shell option: ${shell}`);
+};
+
+export { createScriptExecutor };