bun-workspaces 1.0.0-alpha.3 → 1.0.0-alpha.30

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

@@ -0,0 +1,312 @@
+export interface CliCommandConfig {
+  command: string;
+  isGlobal: boolean;
+  aliases: string[];
+  description: string;
+  options: Record<
+    string,
+    {
+      flags: string[];
+      description: string;
+      values?: string[];
+    }
+  >;
+}
+export type CliCommandName = keyof typeof CLI_COMMANDS_CONFIG;
+export type CliGlobalCommandName = {
+  [K in CliCommandName]: (typeof CLI_COMMANDS_CONFIG)[K] extends {
+    isGlobal: true;
+  }
+    ? K
+    : never;
+}[CliCommandName];
+export type CliProjectCommandName = Exclude<
+  CliCommandName,
+  CliGlobalCommandName
+>;
+export declare const CLI_COMMANDS_CONFIG: {
+  readonly doctor: {
+    readonly command: "doctor";
+    readonly isGlobal: true;
+    readonly aliases: [];
+    readonly description: "Print diagnostic information";
+    readonly options: {
+      readonly json: {
+        readonly flags: ["-j", "--json"];
+        readonly description: "Output as JSON";
+      };
+      readonly pretty: {
+        readonly flags: ["-p", "--pretty"];
+        readonly description: "Pretty print JSON";
+      };
+    };
+  };
+  readonly listWorkspaces: {
+    readonly command: "list-workspaces [workspacePatterns...]";
+    readonly isGlobal: false;
+    readonly aliases: ["ls", "list"];
+    readonly description: "List all workspaces";
+    readonly options: {
+      readonly workspacePatterns: {
+        readonly flags: ["-W", "--workspace-patterns <patterns>"];
+        readonly description: "Workspace patterns to filter workspaces by, separated by commas";
+      };
+      readonly nameOnly: {
+        readonly flags: ["-n", "--name-only"];
+        readonly description: "Only show workspace names";
+      };
+      readonly json: {
+        readonly flags: ["-j", "--json"];
+        readonly description: "Output as JSON";
+      };
+      readonly pretty: {
+        readonly flags: ["-p", "--pretty"];
+        readonly description: "Pretty print JSON";
+      };
+    };
+  };
+  readonly listScripts: {
+    readonly command: "list-scripts";
+    readonly isGlobal: false;
+    readonly aliases: ["ls-scripts"];
+    readonly description: "List all scripts available with their workspaces";
+    readonly options: {
+      readonly nameOnly: {
+        readonly flags: ["-n", "--name-only"];
+        readonly description: "Only show script names";
+      };
+      readonly json: {
+        readonly flags: ["-j", "--json"];
+        readonly description: "Output as JSON";
+      };
+      readonly pretty: {
+        readonly flags: ["-p", "--pretty"];
+        readonly description: "Pretty print JSON";
+      };
+    };
+  };
+  readonly workspaceInfo: {
+    readonly command: "workspace-info <workspaceName>";
+    readonly isGlobal: false;
+    readonly aliases: ["info"];
+    readonly description: "Show information about a workspace";
+    readonly options: {
+      readonly json: {
+        readonly flags: ["-j", "--json"];
+        readonly description: "Output as JSON";
+      };
+      readonly pretty: {
+        readonly flags: ["-p", "--pretty"];
+        readonly description: "Pretty print JSON";
+      };
+    };
+  };
+  readonly scriptInfo: {
+    readonly command: "script-info <script>";
+    readonly isGlobal: false;
+    readonly aliases: [];
+    readonly description: "Show information about a script";
+    readonly options: {
+      readonly workspacesOnly: {
+        readonly flags: ["-w", "--workspaces-only"];
+        readonly description: "Only show script's workspace names";
+      };
+      readonly json: {
+        readonly flags: ["-j", "--json"];
+        readonly description: "Output as JSON";
+      };
+      readonly pretty: {
+        readonly flags: ["-p", "--pretty"];
+        readonly description: "Pretty print JSON";
+      };
+    };
+  };
+  readonly runScript: {
+    readonly command: "run-script [script] [workspacePatterns...]";
+    readonly isGlobal: false;
+    readonly aliases: ["run"];
+    readonly description: 'Run a script in all workspaces that have it in their "scripts" field in package.json';
+    readonly options: {
+      readonly script: {
+        readonly flags: ["-S", "--script <script>"];
+        readonly description: "The script to run.";
+      };
+      readonly workspacePatterns: {
+        readonly flags: ["-W", "--workspace-patterns <patterns>"];
+        readonly description: "Workspace patterns to filter workspaces by, separated by commas";
+      };
+      readonly parallel: {
+        readonly flags: ["-P", "--parallel [max]"];
+        readonly description: "Run the scripts in parallel. Pass an optional number, percentage, or keyword: default | auto | unbounded";
+      };
+      readonly args: {
+        readonly flags: ["-a", "--args <args>"];
+        readonly description: "Args to append to the script command";
+      };
+      readonly noPrefix: {
+        readonly flags: ["-N", "--no-prefix"];
+        readonly description: "Do not prefix the workspace name to the script output";
+      };
+      readonly inline: {
+        readonly flags: ["-i", "--inline"];
+        readonly description: "Run the script as an inline command from the workspace directory";
+      };
+      readonly inlineName: {
+        readonly flags: ["-I", "--inline-name <name>"];
+        readonly description: "An optional name for the script when --inline is passed";
+      };
+      readonly shell: {
+        readonly flags: ["-s", "--shell <shell>"];
+        readonly values: ["bun", "system", "default"];
+        readonly description: "When using --inline, the shell to use to run the script";
+      };
+      readonly jsonOutfile: {
+        readonly flags: ["-j", "--json-outfile <file>"];
+        readonly description: "Output results in a JSON file";
+      };
+    };
+  };
+};
+export declare const getCliCommandConfig: (commandName: CliCommandName) =>
+  | {
+      readonly command: "doctor";
+      readonly isGlobal: true;
+      readonly aliases: [];
+      readonly description: "Print diagnostic information";
+      readonly options: {
+        readonly json: {
+          readonly flags: ["-j", "--json"];
+          readonly description: "Output as JSON";
+        };
+        readonly pretty: {
+          readonly flags: ["-p", "--pretty"];
+          readonly description: "Pretty print JSON";
+        };
+      };
+    }
+  | {
+      readonly command: "list-workspaces [workspacePatterns...]";
+      readonly isGlobal: false;
+      readonly aliases: ["ls", "list"];
+      readonly description: "List all workspaces";
+      readonly options: {
+        readonly workspacePatterns: {
+          readonly flags: ["-W", "--workspace-patterns <patterns>"];
+          readonly description: "Workspace patterns to filter workspaces by, separated by commas";
+        };
+        readonly nameOnly: {
+          readonly flags: ["-n", "--name-only"];
+          readonly description: "Only show workspace names";
+        };
+        readonly json: {
+          readonly flags: ["-j", "--json"];
+          readonly description: "Output as JSON";
+        };
+        readonly pretty: {
+          readonly flags: ["-p", "--pretty"];
+          readonly description: "Pretty print JSON";
+        };
+      };
+    }
+  | {
+      readonly command: "list-scripts";
+      readonly isGlobal: false;
+      readonly aliases: ["ls-scripts"];
+      readonly description: "List all scripts available with their workspaces";
+      readonly options: {
+        readonly nameOnly: {
+          readonly flags: ["-n", "--name-only"];
+          readonly description: "Only show script names";
+        };
+        readonly json: {
+          readonly flags: ["-j", "--json"];
+          readonly description: "Output as JSON";
+        };
+        readonly pretty: {
+          readonly flags: ["-p", "--pretty"];
+          readonly description: "Pretty print JSON";
+        };
+      };
+    }
+  | {
+      readonly command: "workspace-info <workspaceName>";
+      readonly isGlobal: false;
+      readonly aliases: ["info"];
+      readonly description: "Show information about a workspace";
+      readonly options: {
+        readonly json: {
+          readonly flags: ["-j", "--json"];
+          readonly description: "Output as JSON";
+        };
+        readonly pretty: {
+          readonly flags: ["-p", "--pretty"];
+          readonly description: "Pretty print JSON";
+        };
+      };
+    }
+  | {
+      readonly command: "script-info <script>";
+      readonly isGlobal: false;
+      readonly aliases: [];
+      readonly description: "Show information about a script";
+      readonly options: {
+        readonly workspacesOnly: {
+          readonly flags: ["-w", "--workspaces-only"];
+          readonly description: "Only show script's workspace names";
+        };
+        readonly json: {
+          readonly flags: ["-j", "--json"];
+          readonly description: "Output as JSON";
+        };
+        readonly pretty: {
+          readonly flags: ["-p", "--pretty"];
+          readonly description: "Pretty print JSON";
+        };
+      };
+    }
+  | {
+      readonly command: "run-script [script] [workspacePatterns...]";
+      readonly isGlobal: false;
+      readonly aliases: ["run"];
+      readonly description: 'Run a script in all workspaces that have it in their "scripts" field in package.json';
+      readonly options: {
+        readonly script: {
+          readonly flags: ["-S", "--script <script>"];
+          readonly description: "The script to run.";
+        };
+        readonly workspacePatterns: {
+          readonly flags: ["-W", "--workspace-patterns <patterns>"];
+          readonly description: "Workspace patterns to filter workspaces by, separated by commas";
+        };
+        readonly parallel: {
+          readonly flags: ["-P", "--parallel [max]"];
+          readonly description: "Run the scripts in parallel. Pass an optional number, percentage, or keyword: default | auto | unbounded";
+        };
+        readonly args: {
+          readonly flags: ["-a", "--args <args>"];
+          readonly description: "Args to append to the script command";
+        };
+        readonly noPrefix: {
+          readonly flags: ["-N", "--no-prefix"];
+          readonly description: "Do not prefix the workspace name to the script output";
+        };
+        readonly inline: {
+          readonly flags: ["-i", "--inline"];
+          readonly description: "Run the script as an inline command from the workspace directory";
+        };
+        readonly inlineName: {
+          readonly flags: ["-I", "--inline-name <name>"];
+          readonly description: "An optional name for the script when --inline is passed";
+        };
+        readonly shell: {
+          readonly flags: ["-s", "--shell <shell>"];
+          readonly values: ["bun", "system", "default"];
+          readonly description: "When using --inline, the shell to use to run the script";
+        };
+        readonly jsonOutfile: {
+          readonly flags: ["-j", "--json-outfile <file>"];
+          readonly description: "Output results in a JSON file";
+        };
+      };
+    };
+export declare const getCliCommandNames: () => CliCommandName[];

package/src/cli/commands/commandsConfig.mjs

@@ -0,0 +1,155 @@
+import { SCRIPT_SHELL_OPTIONS } from "../../runScript/scriptShellOption.mjs"; // CONCATENATED MODULE: external "../../runScript/scriptShellOption.mjs"
+// CONCATENATED MODULE: ./src/cli/commands/commandsConfig.ts
+
+const CLI_COMMANDS_CONFIG = {
+  doctor: {
+    command: "doctor",
+    isGlobal: true,
+    aliases: [],
+    description: "Print diagnostic information",
+    options: {
+      json: {
+        flags: ["-j", "--json"],
+        description: "Output as JSON",
+      },
+      pretty: {
+        flags: ["-p", "--pretty"],
+        description: "Pretty print JSON",
+      },
+    },
+  },
+  listWorkspaces: {
+    command: "list-workspaces [workspacePatterns...]",
+    isGlobal: false,
+    aliases: ["ls", "list"],
+    description: "List all workspaces",
+    options: {
+      workspacePatterns: {
+        flags: ["-W", "--workspace-patterns <patterns>"],
+        description:
+          "Workspace patterns to filter workspaces by, separated by commas",
+      },
+      nameOnly: {
+        flags: ["-n", "--name-only"],
+        description: "Only show workspace names",
+      },
+      json: {
+        flags: ["-j", "--json"],
+        description: "Output as JSON",
+      },
+      pretty: {
+        flags: ["-p", "--pretty"],
+        description: "Pretty print JSON",
+      },
+    },
+  },
+  listScripts: {
+    command: "list-scripts",
+    isGlobal: false,
+    aliases: ["ls-scripts"],
+    description: "List all scripts available with their workspaces",
+    options: {
+      nameOnly: {
+        flags: ["-n", "--name-only"],
+        description: "Only show script names",
+      },
+      json: {
+        flags: ["-j", "--json"],
+        description: "Output as JSON",
+      },
+      pretty: {
+        flags: ["-p", "--pretty"],
+        description: "Pretty print JSON",
+      },
+    },
+  },
+  workspaceInfo: {
+    command: "workspace-info <workspaceName>",
+    isGlobal: false,
+    aliases: ["info"],
+    description: "Show information about a workspace",
+    options: {
+      json: {
+        flags: ["-j", "--json"],
+        description: "Output as JSON",
+      },
+      pretty: {
+        flags: ["-p", "--pretty"],
+        description: "Pretty print JSON",
+      },
+    },
+  },
+  scriptInfo: {
+    command: "script-info <script>",
+    isGlobal: false,
+    aliases: [],
+    description: "Show information about a script",
+    options: {
+      workspacesOnly: {
+        flags: ["-w", "--workspaces-only"],
+        description: "Only show script's workspace names",
+      },
+      json: {
+        flags: ["-j", "--json"],
+        description: "Output as JSON",
+      },
+      pretty: {
+        flags: ["-p", "--pretty"],
+        description: "Pretty print JSON",
+      },
+    },
+  },
+  runScript: {
+    command: "run-script [script] [workspacePatterns...]",
+    isGlobal: false,
+    aliases: ["run"],
+    description:
+      'Run a script in all workspaces that have it in their "scripts" field in package.json',
+    options: {
+      script: {
+        flags: ["-S", "--script <script>"],
+        description: "The script to run.",
+      },
+      workspacePatterns: {
+        flags: ["-W", "--workspace-patterns <patterns>"],
+        description:
+          "Workspace patterns to filter workspaces by, separated by commas",
+      },
+      parallel: {
+        flags: ["-P", "--parallel [max]"],
+        description:
+          "Run the scripts in parallel. Pass an optional number, percentage, or keyword: default | auto | unbounded",
+      },
+      args: {
+        flags: ["-a", "--args <args>"],
+        description: "Args to append to the script command",
+      },
+      noPrefix: {
+        flags: ["-N", "--no-prefix"],
+        description: "Do not prefix the workspace name to the script output",
+      },
+      inline: {
+        flags: ["-i", "--inline"],
+        description:
+          "Run the script as an inline command from the workspace directory",
+      },
+      inlineName: {
+        flags: ["-I", "--inline-name <name>"],
+        description: "An optional name for the script when --inline is passed",
+      },
+      shell: {
+        flags: ["-s", "--shell <shell>"],
+        values: [...SCRIPT_SHELL_OPTIONS, "default"],
+        description: `When using --inline, the shell to use to run the script`,
+      },
+      jsonOutfile: {
+        flags: ["-j", "--json-outfile <file>"],
+        description: "Output results in a JSON file",
+      },
+    },
+  },
+};
+const getCliCommandConfig = (commandName) => CLI_COMMANDS_CONFIG[commandName];
+const getCliCommandNames = () => Object.keys(CLI_COMMANDS_CONFIG);
+
+export { CLI_COMMANDS_CONFIG, getCliCommandConfig, getCliCommandNames };

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

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

package/src/cli/commands/handleRunScript.mjs

@@ -0,0 +1,217 @@
+import fs from "fs";
+import path from "path";
+import { logger } from "../../internal/logger/index.mjs";
+import { sortWorkspaces } from "../../workspaces/index.mjs";
+import {
+  commandOutputLogger,
+  handleProjectCommand,
+} from "./commandHandlerUtils.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "../../workspaces/index.mjs"
+// CONCATENATED MODULE: external "./commandHandlerUtils.mjs"
+// CONCATENATED MODULE: ./src/cli/commands/handleRunScript.ts
+
+const runScript = handleProjectCommand(
+  "runScript",
+  async (
+    { project, postTerminatorArgs },
+    _script,
+    _workspacePatterns,
+    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 (_script && options.script) {
+      _workspacePatterns.splice(0, 0, _script);
+    }
+    const script = options.script || _script;
+    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 (_workspacePatterns.length && options.workspacePatterns) {
+      logger.error(
+        "CLI syntax error: Cannot use both inline workspace patterns and --workspace-patterns|-W option",
+      );
+      process.exit(1);
+    }
+    const workspacePatterns = _workspacePatterns?.length
+      ? _workspacePatterns
+      : (options.workspacePatterns?.split(",") ?? []);
+    logger.debug(
+      `Command: Run script ${JSON.stringify(script)} for ${workspacePatterns.length ? "workspaces " + workspacePatterns.join(", ") : "all workspaces"} (parallel: ${!!options.parallel}, args: ${JSON.stringify(scriptArgs)})`,
+    );
+    let workspaces = workspacePatterns.length
+      ? workspacePatterns
+          .flatMap((workspacePattern) => {
+            if (workspacePattern.includes("*")) {
+              return project
+                .findWorkspacesByPattern(workspacePattern)
+                .filter(
+                  (workspace) =>
+                    options.inline || workspace.scripts.includes(script),
+                )
+                .map(({ name }) => name);
+            }
+            return [workspacePattern];
+          })
+          .map((workspaceName) => {
+            const workspace = project.findWorkspaceByNameOrAlias(workspaceName);
+            if (!workspace) {
+              logger.error(
+                `Workspace name or alias not found: ${JSON.stringify(workspaceName)}`,
+              );
+              process.exit(1);
+            }
+            return workspace;
+          })
+          .filter(Boolean)
+      : options.inline
+        ? project.workspaces
+        : project.listWorkspacesWithScript(script);
+    workspaces = sortWorkspaces(workspaces);
+    if (!workspaces.length) {
+      if (
+        workspacePatterns.length === 1 &&
+        !workspacePatterns[0].includes("*")
+      ) {
+        logger.error(
+          `Workspace not found: ${JSON.stringify(workspacePatterns[0])}`,
+        );
+      } else {
+        logger.error(
+          `No ${workspacePatterns.length ? "matching " : ""}workspaces found${options.inline ? " in the project" : " with script " + JSON.stringify(script)}`,
+        );
+      }
+      process.exit(1);
+    }
+    if (
+      !options.inline &&
+      !workspaces.some((workspace) => workspace.scripts.includes(script))
+    ) {
+      logger.error(
+        `Script not found in target workspace${workspaces.length === 1 ? "" : "s"}: ${JSON.stringify(script)}`,
+      );
+      process.exit(1);
+    }
+    workspaces.sort((a, b) => a.path.localeCompare(b.path));
+    const { output, summary } = project.runScriptAcrossWorkspaces({
+      workspacePatterns: workspaces.map(({ name }) => name),
+      script,
+      inline: options.inline
+        ? options.inlineName || options.shell
+          ? {
+              scriptName: options.inlineName,
+              shell: options.shell,
+            }
+          : true
+        : undefined,
+      args: scriptArgs,
+      parallel:
+        typeof options.parallel === "boolean" ||
+        typeof options.parallel === "undefined"
+          ? options.parallel
+          : options.parallel === "true"
+            ? true
+            : options.parallel === "false"
+              ? false
+              : {
+                  max: options.parallel,
+                },
+    });
+    const scriptName = options.inline
+      ? options.inlineName || "(inline)"
+      : script;
+    const handleOutput = async () => {
+      if (logger.printLevel === "silent") return;
+      for await (const { outputChunk, scriptMetadata } of output) {
+        commandOutputLogger.logOutput(
+          outputChunk.decode(),
+          "info",
+          process[outputChunk.streamName],
+          options.prefix
+            ? `[${scriptMetadata.workspace.name}:${scriptName}] `
+            : "",
+        );
+      }
+    };
+    handleOutput();
+    const exitResults = await summary;
+    exitResults.scriptResults.forEach(
+      ({ success, metadata: { workspace }, exitCode }) => {
+        logger.info(
+          `${success ? "✅" : "❌"} ${workspace.name}: ${scriptName}${exitCode ? ` (exited with code ${exitCode})` : ""}`,
+        );
+      },
+    );
+    const s = exitResults.scriptResults.length === 1 ? "" : "s";
+    if (exitResults.failureCount) {
+      const message = `${exitResults.failureCount} of ${exitResults.scriptResults.length} script${s} failed`;
+      logger.info(message);
+    } else {
+      logger.info(
+        `${exitResults.scriptResults.length} script${s} ran successfully`,
+      );
+    }
+    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 {
+          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 {
+        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 };