bun-workspaces 0.2.0 → 1.0.0-alpha

package/src/cli/projectCommands.ts

@@ -1,16 +1,17 @@
 import { type Command } from "commander";
-import { logger } from "../internal/logger";
+import { BunWorkspacesError } from "../internal/error";
+import { logger, createLogger } from "../internal/logger";
 import type { Project } from "../project";
 import type { Workspace } from "../workspaces";
 
 export interface ProjectCommandsContext {
   project: Project;
   program: Command;
-  printLines: (...lines: string[]) => void;
 }
 
 const createWorkspaceInfoLines = (workspace: Workspace) => [
   `Workspace: ${workspace.name}`,
+  ` - Aliases: ${workspace.aliases.join(", ")}`,
   ` - Path: ${workspace.path}`,
   ` - Glob Match: ${workspace.matchPattern}`,
   ` - Scripts: ${Object.keys(workspace.packageJson.scripts).sort().join(", ")}`,
@@ -21,132 +22,194 @@ const createScriptInfoLines = (script: string, workspaces: Workspace[]) => [
   ...workspaces.map((workspace) => ` - ${workspace.name}`),
 ];
 
-const listWorkspaces = ({
-  program,
-  project,
-  printLines,
-}: ProjectCommandsContext) => {
+const createJsonLines = (data: unknown, options: { pretty: boolean }) =>
+  JSON.stringify(data, null, options.pretty ? 2 : undefined).split("\n");
+
+export const commandOutputLogger = createLogger("");
+commandOutputLogger.printLevel = "info";
+
+const listWorkspaces = ({ program, project }: ProjectCommandsContext) => {
   program
     .command("list-workspaces [pattern]")
     .aliases(["ls", "list"])
     .description("List all workspaces")
     .option("--name-only", "Only show workspace names")
-    .action((pattern, options) => {
-      logger.debug("Command: List workspaces");
+    .option("--json", "Output as JSON")
+    .option("--pretty", "Pretty print JSON")
+    .action(
+      (
+        pattern,
+        options: { nameOnly: boolean; json: boolean; pretty: boolean },
+      ) => {
+        logger.debug(
+          `Command: List workspaces (options: ${JSON.stringify(options)})`,
+        );
 
-      if (options.more) {
-        logger.debug("Showing more metadata");
-      }
+        const lines: string[] = [];
 
-      const lines: string[] = [];
-      (pattern
-        ? project.findWorkspacesByPattern(pattern)
-        : project.workspaces
-      ).forEach((workspace) => {
-        if (options.nameOnly) {
-          lines.push(workspace.name);
+        const workspaces = pattern
+          ? project.findWorkspacesByPattern(pattern)
+          : project.workspaces;
+
+        if (options.json) {
+          lines.push(
+            ...createJsonLines(
+              options.nameOnly
+                ? workspaces.map(({ name }) => name)
+                : workspaces,
+              options,
+            ),
+          );
         } else {
-          lines.push(...createWorkspaceInfoLines(workspace));
+          workspaces.forEach((workspace) => {
+            if (options.nameOnly) {
+              lines.push(workspace.name);
+            } else {
+              lines.push(...createWorkspaceInfoLines(workspace));
+            }
+          });
         }
-      });
 
-      if (!lines.length) {
-        lines.push("No workspaces found");
-      }
+        if (!lines.length) {
+          logger.info("No workspaces found");
+        }
 
-      printLines(...lines);
-    });
+        if (lines.length) commandOutputLogger.info(lines.join("\n"));
+      },
+    );
 };
 
-const listScripts = ({
-  program,
-  project,
-  printLines,
-}: ProjectCommandsContext) => {
+const listScripts = ({ program, project }: ProjectCommandsContext) => {
   program
     .command("list-scripts")
     .description("List all scripts available with their workspaces")
     .option("--name-only", "Only show script names")
-    .action((options) => {
-      logger.debug("Command: List scripts");
-
-      const scripts = project.listScriptsWithWorkspaces();
-      const lines: string[] = [];
-      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));
-          }
-        });
+    .option("--json", "Output as JSON")
+    .option("--pretty", "Pretty print JSON")
+    .action(
+      (options: { nameOnly: boolean; json: boolean; pretty: boolean }) => {
+        logger.debug(
+          `Command: List scripts (options: ${JSON.stringify(options)})`,
+        );
 
-      if (!lines.length) {
-        lines.push("No scripts found");
-      }
+        const scripts = project.listScriptsWithWorkspaces();
+        const lines: string[] = [];
+
+        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) {
+            logger.info("No scripts found");
+          }
+        }
 
-      printLines(...lines);
-    });
+        if (lines.length) commandOutputLogger.info(lines.join("\n"));
+      },
+    );
 };
 
-const workspaceInfo = ({
-  program,
-  project,
-  printLines,
-}: ProjectCommandsContext) => {
+const workspaceInfo = ({ program, project }: ProjectCommandsContext) => {
   program
     .command("workspace-info <workspace>")
     .aliases(["info"])
     .description("Show information about a workspace")
-    .action((workspaceName) => {
-      logger.debug(`Command: Workspace info for ${workspaceName}`);
+    .option("--json", "Output as JSON")
+    .option("--pretty", "Pretty print JSON")
+    .action(
+      (workspaceName: string, options: { json: boolean; pretty: boolean }) => {
+        logger.debug(
+          `Command: Workspace info for ${workspaceName} (options: ${JSON.stringify(options)})`,
+        );
 
-      const workspace = project.findWorkspaceByName(workspaceName);
-      if (!workspace) {
-        logger.error(`Workspace not found: ${JSON.stringify(workspaceName)}`);
-        return;
-      }
+        const workspace = project.findWorkspaceByName(workspaceName);
+        if (!workspace) {
+          logger.error(
+            `Workspace not found: (options: ${JSON.stringify(workspaceName)})`,
+          );
+          return;
+        }
 
-      printLines(...createWorkspaceInfoLines(workspace));
-    });
+        commandOutputLogger.info(
+          (options.json
+            ? createJsonLines(workspace, options)
+            : createWorkspaceInfoLines(workspace)
+          ).join("\n"),
+        );
+      },
+    );
 };
 
-const scriptInfo = ({
-  program,
-  project,
-  printLines,
-}: ProjectCommandsContext) => {
+const scriptInfo = ({ program, project }: ProjectCommandsContext) => {
   program
     .command("script-info <script>")
     .description("Show information about a script")
     .option("--workspaces-only", "Only show script's workspace names")
-    .action((script, options) => {
-      logger.debug(`Command: Script info for ${script}`);
-
-      const scripts = project.listScriptsWithWorkspaces();
-      const scriptMetadata = scripts[script];
-      if (!scriptMetadata) {
-        printLines(
-          `Script not found: ${JSON.stringify(
-            script,
-          )} (available: ${Object.keys(scripts).join(", ")})`,
+    .option("--json", "Output as JSON")
+    .option("--pretty", "Pretty print JSON")
+    .action(
+      (
+        script,
+        options: { workspacesOnly: boolean; json: boolean; pretty: boolean },
+      ) => {
+        logger.debug(
+          `Command: Script info for ${script} (options: ${JSON.stringify(options)})`,
         );
-        return;
-      }
-      printLines(
-        ...(options.workspacesOnly
-          ? scriptMetadata.workspaces.map(({ name }) => name)
-          : createScriptInfoLines(script, scriptMetadata.workspaces)),
-      );
-    });
+
+        const scripts = project.listScriptsWithWorkspaces();
+        const scriptMetadata = scripts[script];
+        if (!scriptMetadata) {
+          logger.error(
+            `Script not found: ${JSON.stringify(
+              script,
+            )} (available: ${Object.keys(scripts).join(", ")})`,
+          );
+          return;
+        }
+        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"),
+        );
+      },
+    );
 };
 
-const runScript = ({
-  program,
-  project,
-  printLines,
-}: ProjectCommandsContext) => {
+const runScript = ({ program, project }: ProjectCommandsContext) => {
   program
     .command("run <script> [workspaces...]")
     .description("Run a script in all workspaces")
@@ -201,31 +264,45 @@ const runScript = ({
         scriptName,
         workspace,
       }: (typeof scriptCommands)[number]) => {
+        const commandLogger = createLogger(`${workspace.name}:${scriptName}`);
+
         const splitCommand = command.command.split(/\s+/g);
 
-        logger.debug(
+        commandLogger.debug(
           `Running script ${scriptName} in workspace ${workspace.name} (cwd: ${
             command.cwd
           }): ${splitCommand.join(" ")}`,
         );
 
-        const silent = logger.level === "silent";
-
-        if (!silent) {
-          printLines(
-            `Running script ${JSON.stringify(
-              scriptName,
-            )} in workspace ${JSON.stringify(workspace.name)}`,
-          );
-        }
+        const isSilent = logger.printLevel === "silent";
 
         const proc = Bun.spawn(command.command.split(/\s+/g), {
           cwd: command.cwd,
           env: process.env,
-          stdout: silent ? "ignore" : "inherit",
-          stderr: silent ? "ignore" : "inherit",
+          stdout: isSilent ? "ignore" : "pipe",
+          stderr: isSilent ? "ignore" : "pipe",
         });
 
+        const linePrefix = `[${workspace.name}:${scriptName}] `;
+
+        if (proc.stdout) {
+          for await (const chunk of proc.stdout) {
+            const line = new TextDecoder().decode(chunk).trim();
+            line.split("\n").forEach((line) => {
+              commandLogger.info(linePrefix + line);
+            });
+          }
+        }
+
+        if (proc.stderr) {
+          for await (const chunk of proc.stderr) {
+            const line = new TextDecoder().decode(chunk).trim();
+            line.split("\n").forEach((line) => {
+              commandLogger.error(linePrefix + line);
+            });
+          }
+        }
+
         await proc.exited;
 
         return {
@@ -233,30 +310,20 @@ const runScript = ({
           workspace,
           command,
           success: proc.exitCode === 0,
+          error:
+            proc.exitCode === 0
+              ? null
+              : new BunWorkspacesError(
+                  `Script exited with code ${proc.exitCode}`,
+                ),
         };
       };
 
-      const handleError = (error: unknown, workspace: string) => {
-        logger.error(error);
-        program.error(
-          `Script failed in ${workspace} (error: ${JSON.stringify((error as Error).message ?? error)})`,
-        );
-      };
-
-      const handleResult = ({
-        scriptName,
-        workspace,
-        success,
-      }: (typeof scriptCommands)[number] & { success: boolean }) => {
-        logger.info(
-          `${success ? "✅" : "❌"} ${workspace.name}: ${scriptName}`,
-        );
-        if (!success) {
-          program.error(
-            `Script ${scriptName} failed in workspace ${workspace.name}`,
-          );
-        }
-      };
+      const results = [] as {
+        success: boolean;
+        workspaceName: string;
+        error: Error | null;
+      }[];
 
       if (options.parallel) {
         let i = 0;
@@ -264,9 +331,17 @@ const runScript = ({
           scriptCommands.map(runCommand),
         )) {
           if (result.status === "rejected") {
-            handleError(result.reason, workspaces[i]);
+            results.push({
+              success: false,
+              workspaceName: workspaces[i],
+              error: result.reason,
+            });
           } else {
-            handleResult(result.value);
+            results.push({
+              success: result.value.success,
+              workspaceName: workspaces[i],
+              error: result.value.error,
+            });
           }
           i++;
         }
@@ -275,12 +350,39 @@ const runScript = ({
         for (const command of scriptCommands) {
           try {
             const result = await runCommand(command);
-            handleResult(result);
+            results.push({
+              success: result.success,
+              workspaceName: workspaces[i],
+              error: result.error,
+            });
           } catch (error) {
-            handleError(error, workspaces[i]);
+            results.push({
+              success: false,
+              workspaceName: workspaces[i],
+              error: error as Error,
+            });
           }
+          i++;
         }
-        i++;
+      }
+
+      let failCount = 0;
+      results.forEach(({ success, workspaceName }) => {
+        if (!success) failCount++;
+        commandOutputLogger.info(
+          `${success ? "✅" : "❌"} ${workspaceName}: ${script}`,
+        );
+      });
+
+      const s = results.length === 1 ? "" : "s";
+      if (failCount) {
+        const message = `${failCount} of ${results.length} script${s} failed`;
+        commandOutputLogger.info(message);
+        process.exit(1);
+      } else {
+        commandOutputLogger.info(
+          `${results.length} script${s} ran successfully`,
+        );
       }
     });
 };

package/src/config/bunWorkspacesConfig.ts

@@ -0,0 +1,62 @@
+import { validateLogLevel, type LogLevelSetting } from "../internal/logger";
+
+export interface CliConfig {
+  logLevel?: LogLevelSetting;
+}
+
+export interface ProjectConfig {
+  /** A map of aliases to a workspace name */
+  workspaceAliases?: Record<string, string>;
+}
+
+export interface BunWorkspacesConfig {
+  cli?: CliConfig;
+  project?: ProjectConfig;
+}
+
+const validateCliConfig = (cliConfig: CliConfig) => {
+  if (typeof cliConfig !== "object" || Array.isArray(cliConfig)) {
+    throw new Error(`Config file: "cli" must be an object`);
+  }
+
+  if (cliConfig?.logLevel) {
+    validateLogLevel(cliConfig.logLevel);
+  }
+};
+
+const validateProjectConfig = (projectConfig: ProjectConfig) => {
+  if (typeof projectConfig !== "object" || Array.isArray(projectConfig)) {
+    throw new Error(`Config file: "project" must be an object`);
+  }
+
+  if (projectConfig?.workspaceAliases) {
+    if (
+      typeof projectConfig.workspaceAliases !== "object" ||
+      Array.isArray(projectConfig.workspaceAliases)
+    ) {
+      throw new Error(
+        `Config file: project.workspaceAliases must be an object`,
+      );
+    }
+    for (const alias of Object.values(projectConfig.workspaceAliases)) {
+      if (typeof alias !== "string") {
+        throw new Error(
+          `Config file: project.workspaceAliases must be an object with string keys and values`,
+        );
+      }
+    }
+  }
+};
+
+export const validateBunWorkspacesConfig = (config: BunWorkspacesConfig) => {
+  if (typeof config !== "object" || Array.isArray(config)) {
+    throw new Error(`Config file: must be an object`);
+  }
+
+  if (typeof config.cli !== "undefined") {
+    validateCliConfig(config.cli);
+  }
+  if (typeof config.project !== "undefined") {
+    validateProjectConfig(config.project);
+  }
+};

package/src/config/configFile.ts

@@ -0,0 +1,33 @@
+import fs from "fs";
+import path from "path";
+import {
+  validateBunWorkspacesConfig,
+  type BunWorkspacesConfig,
+} from "./bunWorkspacesConfig";
+
+export const DEFAULT_CONFIG_FILE_PATH = "bw.json";
+
+export const loadConfigFile = (filePath?: string, rootDir = ".") => {
+  if (!filePath) {
+    const defaultFilePath = path.resolve(rootDir, DEFAULT_CONFIG_FILE_PATH);
+    if (fs.existsSync(defaultFilePath)) {
+      filePath = defaultFilePath;
+    } else {
+      return null;
+    }
+  }
+
+  filePath = path.resolve(rootDir, filePath);
+
+  const configFile = fs.readFileSync(filePath, "utf8");
+
+  try {
+    const json = JSON.parse(configFile);
+    validateBunWorkspacesConfig(json);
+    return json as BunWorkspacesConfig;
+  } catch (error) {
+    throw new Error(
+      `Config file: "${filePath}" is not a valid JSON file: ${error}`,
+    );
+  }
+};

package/src/config/index.ts

@@ -0,0 +1,7 @@
+export {
+  validateBunWorkspacesConfig,
+  type BunWorkspacesConfig,
+  type CliConfig,
+  type ProjectConfig,
+} from "./bunWorkspacesConfig";
+export { loadConfigFile, DEFAULT_CONFIG_FILE_PATH } from "./configFile";

package/src/internal/bunVersion.ts

@@ -8,12 +8,14 @@ export const BUILD_BUN_VERSION = rootPackageJson.custom.bunVersion.build;
 export const getRequiredBunVersion = (build?: boolean) =>
   build ? BUILD_BUN_VERSION : LIBRARY_CONSUMER_BUN_VERSION;
 
+const _Bun = typeof Bun === "undefined" ? ({} as typeof Bun) : Bun;
+
 /**
  * Validates that the provided version satisfies the required Bun version
  * specified in the root `package.json`.
  */
 export const validateBunVersion = (version: string, build?: boolean) =>
-  Bun.semver.satisfies(version, getRequiredBunVersion(build));
+  _Bun ? _Bun.semver.satisfies(version, getRequiredBunVersion(build)) : true;
 
 /**
  *
@@ -21,4 +23,4 @@ export const validateBunVersion = (version: string, build?: boolean) =>
  * required Bun version specified in the root `package.json`.
  */
 export const validateCurrentBunVersion = (build?: boolean) =>
-  validateBunVersion(Bun.version, build);
+  validateBunVersion(_Bun?.version, build);

package/src/internal/env.ts

@@ -1 +1,25 @@
-export const IS_TEST = process.env.NODE_ENV === "test";
+const RUNTIME_MODE_VALUES = ["development", "production", "test"] as const;
+
+export type RuntimeMode = "development" | "production" | "test";
+
+const _RUNTIME_MODE: RuntimeMode = ((process.env
+  ._BW_RUNTIME_MODE as RuntimeMode) ||
+  (process.env.NODE_ENV?.match(/test(ing)?/)
+    ? "test"
+    : process.env.NODE_ENV === "development"
+      ? "development"
+      : "production")) as RuntimeMode;
+
+export const RUNTIME_MODE = RUNTIME_MODE_VALUES.includes(_RUNTIME_MODE)
+  ? _RUNTIME_MODE
+  : "production";
+
+if (RUNTIME_MODE !== _RUNTIME_MODE) {
+  console.error(
+    `Env var RUNTIME_MODE has an invalid value: "${_RUNTIME_MODE}". Defaulting to "${RUNTIME_MODE}". Accepted values: ${RUNTIME_MODE_VALUES.join(", ")}.`,
+  );
+}
+
+export const IS_TEST = RUNTIME_MODE === "test";
+export const IS_PRODUCTION = RUNTIME_MODE === "production";
+export const IS_DEVELOPMENT = RUNTIME_MODE === "development";