bun-workspaces 1.0.1-alpha → 1.0.1

package/src/cli/cli.ts

@@ -1,87 +0,0 @@
-import { createCommand, Command } from "commander";
-import packageJson from "../../package.json";
-import {
-  getRequiredBunVersion,
-  validateCurrentBunVersion,
-} from "../internal/bunVersion";
-import { logger } from "../internal/logger";
-import { initializeWithGlobalOptions } from "./globalOptions";
-import { defineProjectCommands } from "./projectCommands";
-
-export interface RunCliOptions {
-  argv?: string | string[];
-}
-
-export interface CliProgram {
-  run: (options?: RunCliOptions) => Promise<void>;
-}
-
-export interface CreateCliProgramOptions {
-  handleError?: (error: Error) => void;
-  postInit?: (program: Command) => unknown;
-  defaultCwd?: string;
-}
-
-export const createCliProgram = ({
-  handleError,
-  postInit,
-  defaultCwd = process.cwd(),
-}: CreateCliProgramOptions = {}): CliProgram => {
-  const run = async ({ argv = process.argv }: RunCliOptions = {}) => {
-    const errorListener =
-      handleError ??
-      ((error) => {
-        logger.error(error);
-        logger.error("Unhandled rejection");
-        process.exit(1);
-      });
-
-    process.on("unhandledRejection", errorListener);
-
-    try {
-      const program = createCommand("bunx bun-workspaces")
-        .description("CLI for utilities for Bun workspaces")
-        .version(packageJson.version)
-        .configureOutput({
-          writeOut: (s) => logger.info(s),
-          writeErr: (s) =>
-            s.startsWith("Usage") ? logger.info(s) : logger.error(s),
-        });
-
-      postInit?.(program);
-
-      if (!validateCurrentBunVersion()) {
-        logger.error(
-          `Bun version mismatch. Required: ${getRequiredBunVersion()}, Found: ${
-            Bun.version
-          }`,
-        );
-        process.exit(1);
-      }
-
-      const args = typeof argv === "string" ? argv.split(" ") : argv;
-
-      const { project } = initializeWithGlobalOptions(
-        program,
-        args,
-        defaultCwd,
-      );
-      if (!project) return;
-
-      defineProjectCommands({
-        program,
-        project,
-      });
-
-      await program.parseAsync(args);
-    } catch (error) {
-      errorListener(error as Error);
-    } finally {
-      process.off("unhandledRejection", errorListener);
-    }
-  };
-
-  return {
-    run,
-  };
-};

package/src/cli/globalOptions.ts

@@ -1,122 +0,0 @@
-import path from "path";
-import { type Command, Option } from "commander";
-import { loadConfigFile, type BunWorkspacesConfig } from "../config";
-import { LOG_LEVELS, logger, type LogLevelSetting } from "../internal/logger";
-import { createProject } from "../project";
-
-export interface CliGlobalOptions {
-  logLevel: LogLevelSetting;
-  cwd: string;
-  configFile?: string;
-}
-
-export type CliGlobalOptionName = keyof CliGlobalOptions;
-
-const getWorkingDirectory = (
-  program: Command,
-  args: string[],
-  defaultCwd: string,
-) => {
-  program.addOption(
-    new Option("-d --cwd <path>", "Working directory").default(defaultCwd),
-  );
-  program.parseOptions(args);
-  return program.opts().cwd;
-};
-
-const getConfig = (program: Command, args: string[]) => {
-  program.addOption(new Option("-c --configFile <path>", "Config file"));
-  program.parseOptions(args);
-  return program.opts().configFile;
-};
-
-const defineGlobalOptions = (
-  program: Command,
-  args: string[],
-  defaultCwd: string,
-) => {
-  const cwd = getWorkingDirectory(program, args, defaultCwd);
-
-  const configFilePath = getConfig(program, args);
-
-  const config = loadConfigFile(configFilePath, cwd);
-
-  const globalOptions: {
-    [K in Exclude<CliGlobalOptionName, "configFile" | "cwd">]: {
-      shortName: string;
-      description: string;
-      defaultValue: CliGlobalOptions[K];
-      values?: readonly CliGlobalOptions[K][];
-      param?: string;
-    };
-  } = {
-    logLevel: {
-      shortName: "l",
-      description: "Log levels",
-      defaultValue:
-        config?.cli?.logLevel ?? (logger.printLevel as LogLevelSetting),
-      values: [...LOG_LEVELS, "silent"],
-      param: "level",
-    },
-  };
-
-  Object.entries(globalOptions).forEach(
-    ([name, { shortName, description, param, values, defaultValue }]) => {
-      const option = new Option(
-        `-${shortName} --${name}${param ? ` <${param}>` : ""}`,
-        description,
-      ).default(defaultValue);
-
-      program.addOption(
-        values?.length ? option.choices(values as string[]) : option,
-      );
-    },
-  );
-
-  return { cwd, config };
-};
-
-const applyGlobalOptions = (
-  options: CliGlobalOptions,
-  config: BunWorkspacesConfig | null,
-) => {
-  logger.printLevel = options.logLevel;
-  logger.debug("Log level: " + options.logLevel);
-
-  const project = createProject({
-    rootDir: options.cwd,
-    workspaceAliases: config?.project?.workspaceAliases ?? {},
-  });
-
-  logger.debug(
-    `Project: ${JSON.stringify(project.name)} (${
-      project.workspaces.length
-    } workspace${project.workspaces.length === 1 ? "" : "s"})`,
-  );
-  logger.debug("Project root: " + path.resolve(project.rootDir));
-
-  return { project };
-};
-
-export const initializeWithGlobalOptions = (
-  program: Command,
-  args: string[],
-  defaultCwd: string,
-) => {
-  program.allowUnknownOption(true);
-
-  const { cwd, config } = defineGlobalOptions(program, args, defaultCwd);
-
-  program.parseOptions(args);
-  program.allowUnknownOption(false);
-
-  const options = program.opts() as CliGlobalOptions;
-
-  return applyGlobalOptions(
-    {
-      ...options,
-      cwd,
-    },
-    config,
-  );
-};

package/src/cli/index.ts

@@ -1 +0,0 @@
-export { createCliProgram as createCli } from "./cli";

package/src/cli/projectCommands.ts

@@ -1,396 +0,0 @@
-import { type Command } from "commander";
-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;
-}
-
-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(", ")}`,
-];
-
-const createScriptInfoLines = (script: string, workspaces: Workspace[]) => [
-  `Script: ${script}`,
-  ...workspaces.map((workspace) => ` - ${workspace.name}`),
-];
-
-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")
-    .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)})`,
-        );
-
-        const lines: string[] = [];
-
-        const workspaces = pattern
-          ? project.findWorkspacesByPattern(pattern)
-          : 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) {
-          logger.info("No workspaces found");
-        }
-
-        if (lines.length) commandOutputLogger.info(lines.join("\n"));
-      },
-    );
-};
-
-const listScripts = ({ program, project }: ProjectCommandsContext) => {
-  program
-    .command("list-scripts")
-    .description("List all scripts available with their workspaces")
-    .option("--name-only", "Only show script names")
-    .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)})`,
-        );
-
-        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");
-          }
-        }
-
-        if (lines.length) commandOutputLogger.info(lines.join("\n"));
-      },
-    );
-};
-
-const workspaceInfo = ({ program, project }: ProjectCommandsContext) => {
-  program
-    .command("workspace-info <workspace>")
-    .aliases(["info"])
-    .description("Show information about a workspace")
-    .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.findWorkspaceByNameOrAlias(workspaceName);
-        if (!workspace) {
-          logger.error(
-            `Workspace not found: (options: ${JSON.stringify(workspaceName)})`,
-          );
-          return;
-        }
-
-        commandOutputLogger.info(
-          (options.json
-            ? createJsonLines(workspace, options)
-            : createWorkspaceInfoLines(workspace)
-          ).join("\n"),
-        );
-      },
-    );
-};
-
-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")
-    .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)})`,
-        );
-
-        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 }: ProjectCommandsContext) => {
-  program
-    .command("run <script> [workspaces...]")
-    .description("Run a script in all workspaces")
-    .option("--parallel", "Run the scripts in parallel")
-    .option("--args <args>", "Args to append to the script command", "")
-    .action(async (script: string, _workspaces: string[], options) => {
-      logger.debug(
-        `Command: Run script ${JSON.stringify(script)} for ${
-          _workspaces.length
-            ? "workspaces " + _workspaces.join(", ")
-            : "all workspaces"
-        } (parallel: ${!!options.parallel}, method: ${JSON.stringify(
-          options.method,
-        )}, args: ${JSON.stringify(options.args)})`,
-      );
-
-      const workspaces = _workspaces.length
-        ? _workspaces.flatMap((workspacePattern) => {
-            if (workspacePattern.includes("*")) {
-              return project
-                .findWorkspacesByPattern(workspacePattern)
-                .filter(({ packageJson: { scripts } }) => scripts?.[script])
-                .map(({ name }) => name);
-            }
-            return [workspacePattern];
-          })
-        : project.listWorkspacesWithScript(script).map(({ name }) => name);
-
-      if (!workspaces.length) {
-        program.error(
-          `No ${_workspaces.length ? "matching " : ""}workspaces found for script ${JSON.stringify(script)}`,
-        );
-      }
-
-      let scriptCommands: ReturnType<typeof project.createScriptCommand>[];
-      try {
-        scriptCommands = workspaces.map((workspaceName) =>
-          project.createScriptCommand({
-            scriptName: script,
-            workspaceName,
-            method: "cd",
-            args: options.args.replace(/<workspace>/g, workspaceName),
-          }),
-        );
-      } catch (error) {
-        program.error((error as Error).message);
-        throw error;
-      }
-
-      const runCommand = async ({
-        command,
-        scriptName,
-        workspace,
-      }: (typeof scriptCommands)[number]) => {
-        const commandLogger = createLogger(`${workspace.name}:${scriptName}`);
-
-        const splitCommand = command.command.split(/\s+/g);
-
-        commandLogger.debug(
-          `Running script ${scriptName} in workspace ${workspace.name} (cwd: ${
-            command.cwd
-          }): ${splitCommand.join(" ")}`,
-        );
-
-        const isSilent = logger.printLevel === "silent";
-
-        const proc = Bun.spawn(command.command.split(/\s+/g), {
-          cwd: command.cwd,
-          env: process.env,
-          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 {
-          scriptName,
-          workspace,
-          command,
-          success: proc.exitCode === 0,
-          error:
-            proc.exitCode === 0
-              ? null
-              : new BunWorkspacesError(
-                  `Script exited with code ${proc.exitCode}`,
-                ),
-        };
-      };
-
-      const results = [] as {
-        success: boolean;
-        workspaceName: string;
-        error: Error | null;
-      }[];
-
-      if (options.parallel) {
-        let i = 0;
-        for await (const result of await Promise.allSettled(
-          scriptCommands.map(runCommand),
-        )) {
-          if (result.status === "rejected") {
-            results.push({
-              success: false,
-              workspaceName: workspaces[i],
-              error: result.reason,
-            });
-          } else {
-            results.push({
-              success: result.value.success,
-              workspaceName: workspaces[i],
-              error: result.value.error,
-            });
-          }
-          i++;
-        }
-      } else {
-        let i = 0;
-        for (const command of scriptCommands) {
-          try {
-            const result = await runCommand(command);
-            results.push({
-              success: result.success,
-              workspaceName: workspaces[i],
-              error: result.error,
-            });
-          } catch (error) {
-            results.push({
-              success: false,
-              workspaceName: workspaces[i],
-              error: error as Error,
-            });
-          }
-          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`,
-        );
-      }
-    });
-};
-
-export const defineProjectCommands = (context: ProjectCommandsContext) => {
-  listWorkspaces(context);
-  listScripts(context);
-  workspaceInfo(context);
-  scriptInfo(context);
-  runScript(context);
-};

package/src/config/bunWorkspacesConfig.ts

@@ -1,62 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

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