bun-workspaces 1.0.1-alpha → 1.0.1

package/src/cli/commands/handleSimpleCommands.mjs

@@ -0,0 +1,174 @@
+import { getDoctorInfo } from "../../doctor/index.mjs";
+import { isJSONObject } from "../../internal/core/index.mjs";
+import { logger } from "../../internal/logger/index.mjs";
+import { ROOT_WORKSPACE_SELECTOR } from "../../project/index.mjs";
+import {
+  commandOutputLogger,
+  createJsonLines,
+  createScriptInfoLines,
+  createWorkspaceInfoLines,
+  handleGlobalCommand,
+  handleProjectCommand,
+  splitWorkspacePatterns,
+} from "./commandHandlerUtils.mjs"; // CONCATENATED MODULE: external "../../doctor/index.mjs"
+// CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "../../project/index.mjs"
+// CONCATENATED MODULE: external "./commandHandlerUtils.mjs"
+// CONCATENATED MODULE: ./src/cli/commands/handleSimpleCommands.ts
+
+const doctor = handleGlobalCommand("doctor", (_, options) => {
+  logger.debug(`Options: ${JSON.stringify(options)}`);
+  const info = getDoctorInfo();
+  if (options.json) {
+    commandOutputLogger.info(
+      JSON.stringify(info, null, options.pretty ? 2 : undefined),
+    );
+  } else {
+    const createEntryLine = ([key, value]) => {
+      const keyName = (
+        key[0].toUpperCase() + key.slice(1).replace(/([A-Z])/g, " $1")
+      ).replace(/os|cpu/gi, (m) => m.toUpperCase());
+      return isJSONObject(value)
+        ? keyName +
+            ":\n - " +
+            Object.entries(value).map(createEntryLine).join("\n - ")
+        : `${keyName}: ${value}`;
+    };
+    commandOutputLogger.info(
+      "bun-workspaces\n" + Object.entries(info).map(createEntryLine).join("\n"),
+    );
+  }
+});
+const listWorkspaces = handleProjectCommand(
+  "listWorkspaces",
+  ({ project }, positionalWorkspacePatterns, options) => {
+    logger.debug(`Options: ${JSON.stringify(options)}`);
+    const lines = [];
+    if (
+      positionalWorkspacePatterns?.length &&
+      options.workspacePatterns?.length
+    ) {
+      logger.error(
+        "CLI syntax error: Cannot use both inline workspace patterns and --workspace-patterns|-W option",
+      );
+      process.exit(1);
+    }
+    const patterns = positionalWorkspacePatterns?.length
+      ? positionalWorkspacePatterns
+      : splitWorkspacePatterns(options.workspacePatterns ?? "");
+    const workspaces = patterns?.length
+      ? project.findWorkspacesByPattern(...patterns)
+      : project.workspaces;
+    if (options.json) {
+      lines.push(
+        ...createJsonLines(
+          options.nameOnly ? workspaces.map(({ name }) => name) : workspaces,
+          options,
+        ),
+      );
+    } else {
+      workspaces.forEach((workspace) => {
+        if (options.nameOnly) {
+          lines.push(workspace.name);
+        } else {
+          lines.push(...createWorkspaceInfoLines(workspace));
+        }
+      });
+    }
+    if (!lines.length && !options.nameOnly) {
+      logger.info("No workspaces found");
+    }
+    if (lines.length) commandOutputLogger.info(lines.join("\n"));
+  },
+);
+const listScripts = handleProjectCommand(
+  "listScripts",
+  ({ project }, options) => {
+    logger.debug(`Options: ${JSON.stringify(options)}`);
+    const scripts = project.mapScriptsToWorkspaces();
+    const lines = [];
+    if (!project.workspaces.length && !options.nameOnly) {
+      logger.info("No workspaces found");
+      return;
+    }
+    if (!Object.keys(scripts).length && !options.nameOnly) {
+      logger.info("No scripts found");
+      return;
+    }
+    if (options.json) {
+      lines.push(
+        ...createJsonLines(
+          options.nameOnly
+            ? Object.keys(scripts)
+            : Object.values(scripts).map(({ workspaces, ...rest }) => ({
+                ...rest,
+                workspaces: workspaces.map(({ name }) => name),
+              })),
+          options,
+        ),
+      );
+    } else {
+      Object.values(scripts)
+        .sort(({ name: nameA }, { name: nameB }) => nameA.localeCompare(nameB))
+        .forEach(({ name, workspaces }) => {
+          if (options.nameOnly) {
+            lines.push(name);
+          } else {
+            lines.push(...createScriptInfoLines(name, workspaces));
+          }
+        });
+    }
+    if (lines.length) commandOutputLogger.info(lines.join("\n"));
+  },
+);
+const workspaceInfo = handleProjectCommand(
+  "workspaceInfo",
+  ({ project }, workspaceName, options) => {
+    logger.debug(`Options: ${JSON.stringify(options)}`);
+    const workspace =
+      workspaceName === ROOT_WORKSPACE_SELECTOR
+        ? project.rootWorkspace
+        : project.findWorkspaceByNameOrAlias(workspaceName);
+    if (!workspace) {
+      logger.error(`Workspace ${JSON.stringify(workspaceName)} not found`);
+      process.exit(1);
+    }
+    commandOutputLogger.info(
+      (options.json
+        ? createJsonLines(workspace, options)
+        : createWorkspaceInfoLines(workspace)
+      ).join("\n"),
+    );
+  },
+);
+const scriptInfo = handleProjectCommand(
+  "scriptInfo",
+  ({ project }, script, options) => {
+    logger.debug(`Options: ${JSON.stringify(options)}`);
+    const scripts = project.mapScriptsToWorkspaces();
+    const scriptMetadata = scripts[script];
+    if (!scriptMetadata) {
+      logger.error(`Script not found: ${JSON.stringify(script)}`);
+      process.exit(1);
+    }
+    commandOutputLogger.info(
+      (options.json
+        ? createJsonLines(
+            options.workspacesOnly
+              ? scriptMetadata.workspaces.map(({ name }) => name)
+              : {
+                  name: scriptMetadata.name,
+                  workspaces: scriptMetadata.workspaces.map(({ name }) => name),
+                },
+            options,
+          )
+        : options.workspacesOnly
+          ? scriptMetadata.workspaces.map(({ name }) => name)
+          : createScriptInfoLines(script, scriptMetadata.workspaces)
+      ).join("\n"),
+    );
+  },
+);
+
+export { doctor, listScripts, listWorkspaces, scriptInfo, workspaceInfo };

package/src/cli/commands/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./commands";
+export * from "./commandsConfig";
+export * from "./runScript";

package/src/cli/commands/index.mjs

@@ -0,0 +1,3 @@
+export * from "./commands.mjs";
+export * from "./commandsConfig.mjs";
+export * from "./runScript/index.mjs"; // CONCATENATED MODULE: ./src/cli/commands/index.ts

package/src/cli/commands/runScript/handleRunScript.d.ts

@@ -0,0 +1,3 @@
+export declare const runScript: (
+  context: import("../commandHandlerUtils").ProjectCommandContext,
+) => import("commander").Command;

package/src/cli/commands/runScript/handleRunScript.mjs

@@ -0,0 +1,249 @@
+import fs from "fs";
+import path from "path";
+import { logger } from "../../../internal/logger/index.mjs";
+import {
+  handleProjectCommand,
+  splitWorkspacePatterns,
+} from "../commandHandlerUtils.mjs";
+import { DEFAULT_GROUPED_LINES } from "../commandsConfig.mjs";
+import {
+  getDefaultOutputStyle,
+  validateOutputStyle,
+} from "./output/outputStyle.mjs";
+import {
+  createScriptEvent,
+  createScriptEventTarget,
+  renderGroupedOutput,
+} from "./output/renderGroupedOutput.mjs";
+import { renderPlainOutput } from "./output/renderPlainOutput.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "../commandHandlerUtils.mjs"
+// CONCATENATED MODULE: external "../commandsConfig.mjs"
+// CONCATENATED MODULE: external "./output/outputStyle.mjs"
+// CONCATENATED MODULE: external "./output/renderGroupedOutput.mjs"
+// CONCATENATED MODULE: external "./output/renderPlainOutput.mjs"
+// CONCATENATED MODULE: ./src/cli/commands/runScript/handleRunScript.ts
+
+const runScript = handleProjectCommand(
+  "runScript",
+  async (
+    { project, postTerminatorArgs, outputWriters },
+    positionalScript,
+    positionalWorkspacePatterns,
+    options,
+  ) => {
+    options.inlineName = options.inlineName?.trim();
+    options.args = options.args?.trim();
+    options.jsonOutfile = options.jsonOutfile?.trim();
+    options.parallel =
+      typeof options.parallel === "string"
+        ? options.parallel.trim()
+        : options.parallel;
+    if (positionalScript && options.script) {
+      // If script is provided via options, then the first positional argument is actually a workspace pattern
+      positionalWorkspacePatterns.splice(0, 0, positionalScript);
+    }
+    const script = options.script || positionalScript;
+    if (postTerminatorArgs.length && options.args) {
+      logger.error(
+        "CLI syntax error: Cannot use both --args and inline script args after --",
+      );
+      process.exit(1);
+    }
+    const scriptArgs = postTerminatorArgs.length
+      ? postTerminatorArgs.join(" ")
+      : options.args;
+    if (positionalWorkspacePatterns.length && options.workspacePatterns) {
+      logger.error(
+        "CLI syntax error: Cannot use both inline workspace patterns and --workspace-patterns|-W option",
+      );
+      process.exit(1);
+    }
+    const workspacePatterns = positionalWorkspacePatterns?.length
+      ? positionalWorkspacePatterns
+      : splitWorkspacePatterns(options.workspacePatterns ?? "");
+    logger.debug(
+      `Command: Run ${options.inline ? "inline " : ""}script ${JSON.stringify(script)} for ${workspacePatterns.length ? "workspaces " + workspacePatterns.join(", ") : "all workspaces"}`,
+    );
+    logger.debug(`Options: ${JSON.stringify(options)}`);
+    const scriptEventTarget = createScriptEventTarget();
+    const { output, summary, workspaces } = project.runScriptAcrossWorkspaces({
+      workspacePatterns: workspacePatterns.length
+        ? workspacePatterns
+        : undefined,
+      script,
+      inline: options.inline
+        ? options.inlineName || options.shell
+          ? {
+              scriptName: options.inlineName,
+              shell: options.shell,
+            }
+          : true
+        : undefined,
+      args: scriptArgs,
+      dependencyOrder: options.depOrder,
+      ignoreDependencyFailure: options.ignoreDepFailure,
+      ignoreOutput: logger.printLevel === "silent",
+      onScriptEvent: (event, { workspace, exitResult }) => {
+        setTimeout(() =>
+          // place at end of call stack so listeners in render func receive event
+          scriptEventTarget.dispatchEvent(
+            createScriptEvent[event]({
+              workspace,
+              exitResult,
+            }),
+          ),
+        );
+      },
+      parallel:
+        typeof options.parallel === "boolean" ||
+        typeof options.parallel === "undefined"
+          ? undefined
+          : options.parallel === "true"
+            ? true
+            : options.parallel === "false"
+              ? false
+              : {
+                  max: options.parallel,
+                },
+    });
+    const scriptName = options.inline
+      ? options.inlineName || "(inline)"
+      : script;
+    logger.debug(`Script name: ${scriptName}`);
+    const stripDisruptiveControls = workspaces.length > 1 || !!options.parallel;
+    logger.debug(`Strip disruptive controls: ${stripDisruptiveControls}`);
+    let groupedLines = DEFAULT_GROUPED_LINES;
+    if (options.groupedLines) {
+      if (options.groupedLines === "all") {
+        groupedLines = "all";
+      } else {
+        const parsedGroupedLines = parseInt(options.groupedLines);
+        if (parsedGroupedLines <= 0 || isNaN(parsedGroupedLines)) {
+          logger.error(
+            `Invalid max grouped lines value: ${options.groupedLines}. Must be a positive number or "all".`,
+          );
+          process.exit(1);
+        }
+        groupedLines = parsedGroupedLines;
+      }
+    }
+    logger.debug(`Effective grouped lines: ${JSON.stringify(groupedLines)}`);
+    if (!options.prefix) {
+      logger.warn(
+        "--no-prefix is deprecated and will be removed in a future version. Use --output-style=plain instead.",
+      );
+      if (!options.outputStyle) {
+        options.outputStyle = "plain";
+      }
+    }
+    const outputStyleHandlers = {
+      grouped: () =>
+        renderGroupedOutput(
+          workspaces,
+          output,
+          summary,
+          scriptEventTarget,
+          groupedLines,
+          outputWriters,
+        ),
+      prefixed: () =>
+        renderPlainOutput(output, outputWriters, {
+          prefix: true,
+          stripDisruptiveControls,
+        }),
+      plain: () =>
+        renderPlainOutput(output, outputWriters, {
+          prefix: false,
+          stripDisruptiveControls,
+        }),
+    };
+    const outputStyle = options.outputStyle
+      ? validateOutputStyle(options.outputStyle)
+      : getDefaultOutputStyle();
+    logger.debug(`Effective output style: ${outputStyle}`);
+    await outputStyleHandlers[outputStyle]();
+    const exitResults = await summary;
+    exitResults.scriptResults.forEach(
+      ({ success, metadata: { workspace }, exitCode }) => {
+        const isSkipped = exitCode === -1;
+        if (isSkipped) {
+          logger.info(
+            `➖ ${workspace.name}: ${scriptName} (skipped due to dependency failure)`,
+          );
+        } else {
+          logger.info(
+            `${success ? "✅" : "❌"} ${workspace.name}: ${scriptName}${exitCode ? ` (exited with code ${exitCode})` : ""}`,
+          );
+        }
+      },
+    );
+    const s = exitResults.scriptResults.length === 1 ? "" : "s";
+    const skippedCount = exitResults.scriptResults.filter(
+      ({ exitCode }) => exitCode === -1,
+    ).length;
+    const skippedMessage = skippedCount ? ` (${skippedCount} skipped)` : "";
+    if (exitResults.failureCount) {
+      const message = `${exitResults.failureCount} of ${exitResults.scriptResults.length} script${s} failed${skippedMessage}`;
+      logger.info(message);
+    } else {
+      logger.info(
+        `${exitResults.scriptResults.length} script${s} ran successfully${skippedMessage}`,
+      );
+    }
+    if (options.jsonOutfile) {
+      const fullOutputPath = path.resolve(
+        project.rootDirectory,
+        options.jsonOutfile,
+      );
+      // Check if can make directory
+      const jsonOutputDir = path.dirname(fullOutputPath);
+      if (!fs.existsSync(jsonOutputDir)) {
+        try {
+          logger.debug(
+            `Creating JSON output file directory "${jsonOutputDir}"`,
+          );
+          fs.mkdirSync(jsonOutputDir, {
+            recursive: true,
+          });
+        } catch (error) {
+          logger.error(
+            `Failed to create JSON output file directory "${jsonOutputDir}": ${error}`,
+          );
+          process.exit(1);
+        }
+      } else if (fs.statSync(jsonOutputDir).isFile()) {
+        logger.error(
+          `Given JSON output file directory "${jsonOutputDir}" is an existing file`,
+        );
+        process.exit(1);
+      }
+      // Check if can make file
+      if (
+        fs.existsSync(fullOutputPath) &&
+        fs.statSync(fullOutputPath).isDirectory()
+      ) {
+        logger.error(
+          `Given JSON output file path "${fullOutputPath}" is an existing directory`,
+        );
+        process.exit(1);
+      }
+      try {
+        logger.debug(`Writing JSON output file "${fullOutputPath}"`);
+        fs.writeFileSync(fullOutputPath, JSON.stringify(exitResults, null, 2));
+      } catch (error) {
+        logger.error(
+          `Failed to write JSON output file "${fullOutputPath}": ${error}`,
+        );
+        process.exit(1);
+      }
+      logger.info(`JSON output written to ${fullOutputPath}`);
+    }
+    if (exitResults.failureCount) {
+      process.exit(1);
+    }
+  },
+);
+
+export { runScript };

package/src/cli/commands/runScript/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./handleRunScript";
+export * from "./output/renderPlainOutput";

package/src/cli/commands/runScript/index.mjs

@@ -0,0 +1,2 @@
+export * from "./handleRunScript.mjs";
+export * from "./output/renderPlainOutput.mjs"; // CONCATENATED MODULE: ./src/cli/commands/runScript/index.ts

package/src/cli/commands/runScript/output/index.d.ts

@@ -0,0 +1 @@
+export * from "./renderPlainOutput";

package/src/cli/commands/runScript/output/index.mjs

@@ -0,0 +1 @@
+export * from "./renderPlainOutput.mjs"; // CONCATENATED MODULE: ./src/cli/commands/runScript/output/index.ts

package/src/cli/commands/runScript/output/outputStyle.d.ts

@@ -0,0 +1,8 @@
+export declare const OUTPUT_STYLE_VALUES: readonly [
+  "grouped",
+  "prefixed",
+  "plain",
+];
+export type OutputStyleName = (typeof OUTPUT_STYLE_VALUES)[number];
+export declare const getDefaultOutputStyle: () => OutputStyleName;
+export declare const validateOutputStyle: (style: string) => OutputStyleName;

package/src/cli/commands/runScript/output/outputStyle.mjs

@@ -0,0 +1,17 @@
+import { BunWorkspacesError } from "../../../../internal/core/error/index.mjs";
+import { IS_TTY } from "../../../../internal/core/runtime/terminal.mjs"; // CONCATENATED MODULE: external "../../../../internal/core/error/index.mjs"
+// CONCATENATED MODULE: external "../../../../internal/core/runtime/terminal.mjs"
+// CONCATENATED MODULE: ./src/cli/commands/runScript/output/outputStyle.ts
+
+const OUTPUT_STYLE_VALUES = ["grouped", "prefixed", "plain"];
+const getDefaultOutputStyle = () => (IS_TTY ? "grouped" : "prefixed");
+const validateOutputStyle = (style) => {
+  if (!OUTPUT_STYLE_VALUES.includes(style)) {
+    throw new BunWorkspacesError(
+      `Invalid output style: "${style}" (accepted values: ${OUTPUT_STYLE_VALUES.join(", ")})`,
+    );
+  }
+  return style;
+};
+
+export { OUTPUT_STYLE_VALUES, getDefaultOutputStyle, validateOutputStyle };

package/src/cli/commands/runScript/output/renderGroupedOutput.d.ts

@@ -0,0 +1,73 @@
+import {
+  type TypedEvent,
+  TypedEventTarget,
+} from "../../../../internal/core/language/events/typedEventTarget";
+import type {
+  RunScriptAcrossWorkspacesOutput,
+  RunWorkspaceScriptMetadata,
+} from "../../../../project";
+import type {
+  RunScriptExit,
+  RunScriptsSummary,
+  ScriptEventName,
+} from "../../../../runScript";
+import type { Workspace } from "../../../../workspaces";
+import type { WriteOutputOptions } from "../../../createCli";
+type ScriptEvent = TypedEvent<
+  ScriptEventName,
+  {
+    workspace: Workspace;
+    exitResult: RunScriptExit<RunWorkspaceScriptMetadata> | null;
+  }
+>;
+declare class ScriptEventTarget extends TypedEventTarget<{
+  [key in ScriptEvent["type"]]: ScriptEvent;
+}> {}
+export declare const createScriptEventTarget: () => ScriptEventTarget;
+export declare const createScriptEvent: {
+  start: (
+    properties: Omit<
+      {
+        type: ScriptEventName;
+      } & {
+        workspace: Workspace;
+        exitResult: RunScriptExit<RunWorkspaceScriptMetadata> | null;
+      },
+      "type"
+    >,
+    options?: EventInit,
+  ) => ScriptEvent;
+  skip: (
+    properties: Omit<
+      {
+        type: ScriptEventName;
+      } & {
+        workspace: Workspace;
+        exitResult: RunScriptExit<RunWorkspaceScriptMetadata> | null;
+      },
+      "type"
+    >,
+    options?: EventInit,
+  ) => ScriptEvent;
+  exit: (
+    properties: Omit<
+      {
+        type: ScriptEventName;
+      } & {
+        workspace: Workspace;
+        exitResult: RunScriptExit<RunWorkspaceScriptMetadata> | null;
+      },
+      "type"
+    >,
+    options?: EventInit,
+  ) => ScriptEvent;
+};
+export declare const renderGroupedOutput: (
+  workspaces: Workspace[],
+  output: RunScriptAcrossWorkspacesOutput,
+  summary: Promise<RunScriptsSummary<RunWorkspaceScriptMetadata>>,
+  scriptEventTarget: ScriptEventTarget,
+  activeScriptLines: number | "all",
+  outputWriters: Required<WriteOutputOptions>,
+) => Promise<void>;
+export {};