bun-workspaces 1.0.0-alpha.2 → 1.0.0-alpha.20

package/src/cli/globalOptions/globalOptionsConfig.mjs

@@ -0,0 +1,34 @@
+import { LOG_LEVELS } from "../../internal/logger.mjs"; // CONCATENATED MODULE: external "../../internal/logger.mjs"
+// CONCATENATED MODULE: ./src/cli/globalOptions/globalOptionsConfig.ts
+
+const CLI_GLOBAL_OPTIONS_CONFIG = {
+  logLevel: {
+    mainOption: "--log-level",
+    shortOption: "-l",
+    description: "Log levels",
+    defaultValue: "info",
+    values: [...LOG_LEVELS, "silent"],
+    param: "level",
+  },
+  cwd: {
+    mainOption: "--cwd",
+    shortOption: "-d",
+    description: "Working directory",
+    defaultValue: ".",
+    values: null,
+    param: "path",
+  },
+  configFile: {
+    mainOption: "--config-file",
+    shortOption: "-c",
+    description: "(DEPRECATED) Config file",
+    defaultValue: "",
+    values: null,
+    param: "path",
+  },
+};
+const getCliGlobalOptionConfig = (optionName) =>
+  CLI_GLOBAL_OPTIONS_CONFIG[optionName];
+const getCliGlobalOptionNames = () => Object.keys(CLI_GLOBAL_OPTIONS_CONFIG);
+
+export { getCliGlobalOptionConfig, getCliGlobalOptionNames };

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

@@ -0,0 +1,2 @@
+export * from "./globalOptionsConfig";
+export * from "./globalOptions";

package/src/cli/globalOptions/index.mjs

@@ -0,0 +1,2 @@
+export * from "./globalOptionsConfig.mjs";
+export * from "./globalOptions.mjs"; // CONCATENATED MODULE: ./src/cli/globalOptions/index.ts

package/src/cli/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./createCli";
+export * from "./projectCommands";
+export * from "./globalOptions";

package/src/cli/index.mjs

@@ -0,0 +1,3 @@
+export * from "./createCli.mjs";
+export * from "./projectCommands/index.mjs";
+export * from "./globalOptions/index.mjs"; // CONCATENATED MODULE: ./src/cli/index.ts

package/src/cli/projectCommands/commandHandlerUtils.d.ts

@@ -0,0 +1,31 @@
+import { type Command } from "commander";
+import type { FileSystemProject } from "../../project/implementations/fileSystemProject";
+import type { Workspace } from "../../workspaces";
+import { type CliProjectCommandName } from "./projectCommandsConfig";
+/** @todo DRY use of output text in cases such as having no workspaces/scripts */
+export interface ProjectCommandContext {
+  project: FileSystemProject;
+  projectError: Error | null;
+  program: Command;
+}
+export declare const createWorkspaceInfoLines: (
+  workspace: Workspace,
+) => string[];
+export declare const createScriptInfoLines: (
+  script: string,
+  workspaces: Workspace[],
+) => string[];
+export declare const createJsonLines: (
+  data: unknown,
+  options: {
+    pretty: boolean;
+  },
+) => string[];
+export declare const commandOutputLogger: import("../../internal/logger").Logger;
+export declare const handleCommand: <T extends unknown[]>(
+  commandName: CliProjectCommandName,
+  handler: (
+    context: Omit<ProjectCommandContext, "projectError">,
+    ...actionArgs: T
+  ) => void,
+) => ({ program, project, projectError }: ProjectCommandContext) => Command;

package/src/cli/projectCommands/commandHandlerUtils.mjs

@@ -0,0 +1,52 @@
+import { createLogger } from "../../internal/logger.mjs";
+import { getProjectCommandConfig } from "./projectCommandsConfig.mjs"; // CONCATENATED MODULE: external "../../internal/logger.mjs"
+// CONCATENATED MODULE: external "./projectCommandsConfig.mjs"
+// CONCATENATED MODULE: ./src/cli/projectCommands/commandHandlerUtils.ts
+
+const createWorkspaceInfoLines = (workspace) => [
+  `Workspace: ${workspace.name}`,
+  ` - Aliases: ${workspace.aliases.join(", ")}`,
+  ` - Path: ${workspace.path}`,
+  ` - Glob Match: ${workspace.matchPattern}`,
+  ` - Scripts: ${workspace.scripts.join(", ")}`,
+];
+const createScriptInfoLines = (script, workspaces) => [
+  `Script: ${script}`,
+  ...workspaces.map((workspace) => ` - ${workspace.name}`),
+];
+const createJsonLines = (data, options) =>
+  JSON.stringify(data, null, options.pretty ? 2 : undefined).split("\n");
+const commandOutputLogger = createLogger("");
+commandOutputLogger.printLevel = "info";
+const handleCommand = (commandName, handler) => {
+  const config = getProjectCommandConfig(commandName);
+  return ({ program, project, projectError }) => {
+    program = program
+      .command(config.command)
+      .aliases(config.aliases)
+      .description(config.description);
+    for (const option of Object.values(config.options)) {
+      program.option(option.flags, option.description);
+    }
+    if (!projectError) {
+      program = program.action((...actionArgs) =>
+        handler(
+          {
+            program,
+            project,
+          },
+          ...actionArgs,
+        ),
+      );
+    }
+    return program;
+  };
+};
+
+export {
+  commandOutputLogger,
+  createJsonLines,
+  createScriptInfoLines,
+  createWorkspaceInfoLines,
+  handleCommand,
+};

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

@@ -0,0 +1,5 @@
+export declare const runScript: ({
+  program,
+  project,
+  projectError,
+}: import("./commandHandlerUtils").ProjectCommandContext) => import("commander").Command;

package/src/cli/projectCommands/handleRunScript.mjs

@@ -0,0 +1,153 @@
+import fs from "fs";
+import path from "path";
+import { logger } from "../../internal/logger.mjs";
+import { commandOutputLogger, handleCommand } from "./commandHandlerUtils.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../../internal/logger.mjs"
+// CONCATENATED MODULE: external "./commandHandlerUtils.mjs"
+// CONCATENATED MODULE: ./src/cli/projectCommands/handleRunScript.ts
+
+const runScript = handleCommand(
+  "runScript",
+  async ({ project }, script, _workspaces, options) => {
+    logger.debug(
+      `Command: Run script ${JSON.stringify(script)} for ${_workspaces.length ? "workspaces " + _workspaces.join(", ") : "all workspaces"} (parallel: ${!!options.parallel}, args: ${JSON.stringify(options.args)})`,
+    );
+    const workspaces = _workspaces.length
+      ? _workspaces
+          .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);
+    if (!workspaces.length) {
+      if (_workspaces.length === 1 && !_workspaces[0].includes("*")) {
+        logger.error(`Workspace not found: ${JSON.stringify(_workspaces[0])}`);
+      } else {
+        logger.error(
+          `No ${_workspaces.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,
+      args: options.args,
+      parallel: !!options.parallel,
+    });
+    const scriptName = options.inline ? "(inline)" : script;
+    const handleOutput = async () => {
+      if (logger.printLevel === "silent") return;
+      for await (const { outputChunk, scriptMetadata } of output) {
+        commandOutputLogger.logOutput(
+          outputChunk.text,
+          "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 };

package/src/cli/projectCommands/handleSimpleCommands.d.ts

@@ -0,0 +1,20 @@
+export declare const listWorkspaces: ({
+  program,
+  project,
+  projectError,
+}: import("./commandHandlerUtils").ProjectCommandContext) => import("commander").Command;
+export declare const listScripts: ({
+  program,
+  project,
+  projectError,
+}: import("./commandHandlerUtils").ProjectCommandContext) => import("commander").Command;
+export declare const workspaceInfo: ({
+  program,
+  project,
+  projectError,
+}: import("./commandHandlerUtils").ProjectCommandContext) => import("commander").Command;
+export declare const scriptInfo: ({
+  program,
+  project,
+  projectError,
+}: import("./commandHandlerUtils").ProjectCommandContext) => import("commander").Command;

package/src/cli/projectCommands/handleSimpleCommands.mjs

@@ -0,0 +1,131 @@
+import { logger } from "../../internal/logger.mjs";
+import {
+  commandOutputLogger,
+  createJsonLines,
+  createScriptInfoLines,
+  createWorkspaceInfoLines,
+  handleCommand,
+} from "./commandHandlerUtils.mjs"; // CONCATENATED MODULE: external "../../internal/logger.mjs"
+// CONCATENATED MODULE: external "./commandHandlerUtils.mjs"
+// CONCATENATED MODULE: ./src/cli/projectCommands/handleSimpleCommands.ts
+
+const listWorkspaces = handleCommand(
+  "listWorkspaces",
+  ({ project }, pattern, options) => {
+    logger.debug(
+      `Command: List workspaces (options: ${JSON.stringify(options)})`,
+    );
+    const lines = [];
+    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 && !options.nameOnly) {
+      logger.info("No workspaces found");
+    }
+    if (lines.length) commandOutputLogger.info(lines.join("\n"));
+  },
+);
+const listScripts = handleCommand("listScripts", ({ project }, options) => {
+  logger.debug(`Command: List scripts (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 = handleCommand(
+  "workspaceInfo",
+  ({ project }, workspaceName, options) => {
+    logger.debug(
+      `Command: Workspace info for ${workspaceName} (options: ${JSON.stringify(options)})`,
+    );
+    const workspace = 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 = handleCommand(
+  "scriptInfo",
+  ({ project }, script, options) => {
+    logger.debug(
+      `Command: Script info for ${script} (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 { listScripts, listWorkspaces, scriptInfo, workspaceInfo };

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

@@ -0,0 +1,2 @@
+export * from "./projectCommands";
+export * from "./projectCommandsConfig";

package/src/cli/projectCommands/index.mjs

@@ -0,0 +1,2 @@
+export * from "./projectCommands.mjs";
+export * from "./projectCommandsConfig.mjs"; // CONCATENATED MODULE: ./src/cli/projectCommands/index.ts

package/src/cli/projectCommands/projectCommands.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectCommandContext } from "./commandHandlerUtils";
+export declare const defineProjectCommands: (
+  context: ProjectCommandContext,
+) => void;

package/src/cli/projectCommands/projectCommands.mjs

@@ -0,0 +1,19 @@
+import { runScript } from "./handleRunScript.mjs";
+import {
+  listScripts,
+  listWorkspaces,
+  scriptInfo,
+  workspaceInfo,
+} from "./handleSimpleCommands.mjs"; // CONCATENATED MODULE: external "./handleRunScript.mjs"
+// CONCATENATED MODULE: external "./handleSimpleCommands.mjs"
+// CONCATENATED MODULE: ./src/cli/projectCommands/projectCommands.ts
+
+const defineProjectCommands = (context) => {
+  listWorkspaces(context);
+  listScripts(context);
+  workspaceInfo(context);
+  scriptInfo(context);
+  runScript(context);
+};
+
+export { defineProjectCommands };