bun-workspaces 1.0.1-alpha → 1.0.1

package/src/project/implementations/fileSystemProject.mjs

@@ -0,0 +1,455 @@
+import fs from "fs";
+import path from "path";
+import { loadRootConfig } from "../../config/index.mjs";
+import { getUserEnvVar } from "../../config/userEnvVars/index.mjs";
+import {
+  DEFAULT_TEMP_DIR,
+  isPlainObject,
+  validateJSTypes,
+} from "../../internal/core/index.mjs";
+import { logger } from "../../internal/logger/index.mjs";
+import {
+  createScriptRuntimeEnvVars,
+  interpolateScriptRuntimeMetadata,
+  runScript,
+  runScripts,
+} from "../../runScript/index.mjs";
+import { checkIsRecursiveScript } from "../../runScript/recursion.mjs";
+import { resolveScriptShell } from "../../runScript/scriptShellOption.mjs";
+import { findWorkspaces, sortWorkspaces } from "../../workspaces/index.mjs";
+import { preventDependencyCycles } from "../../workspaces/dependencyGraph/index.mjs";
+import { PROJECT_ERRORS } from "../errors.mjs";
+import {
+  ProjectBase,
+  ROOT_WORKSPACE_SELECTOR,
+  resolveRootWorkspaceSelector,
+  resolveWorkspacePath,
+} from "./projectBase.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../../config/index.mjs"
+// CONCATENATED MODULE: external "../../config/userEnvVars/index.mjs"
+// CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "../../runScript/index.mjs"
+// CONCATENATED MODULE: external "../../runScript/recursion.mjs"
+// CONCATENATED MODULE: external "../../runScript/scriptShellOption.mjs"
+// CONCATENATED MODULE: external "../../workspaces/index.mjs"
+// CONCATENATED MODULE: external "../../workspaces/dependencyGraph/index.mjs"
+// CONCATENATED MODULE: external "../errors.mjs"
+// CONCATENATED MODULE: external "./projectBase.mjs"
+// CONCATENATED MODULE: ./src/project/implementations/fileSystemProject.ts
+
+class _FileSystemProject extends ProjectBase {
+  rootDirectory;
+  workspaces;
+  name;
+  sourceType = "fileSystem";
+  config;
+  rootWorkspace;
+  constructor(options) {
+    super();
+    validateJSTypes(
+      {
+        "rootDirectory option": {
+          value: options.rootDirectory,
+          typeofName: "string",
+          optional: true,
+        },
+        "name option": {
+          value: options.name,
+          typeofName: "string",
+          optional: true,
+        },
+        "includeRootWorkspace option": {
+          value: options.includeRootWorkspace,
+          typeofName: "boolean",
+          optional: true,
+        },
+      },
+      {
+        throw: true,
+      },
+    );
+    if (!_FileSystemProject.#initialized) {
+      DEFAULT_TEMP_DIR.initialize(true);
+      _FileSystemProject.#initialized = true;
+    }
+    this.rootDirectory = path.resolve(
+      process.cwd(),
+      options.rootDirectory ?? "",
+    );
+    const rootConfig = loadRootConfig(this.rootDirectory);
+    const { workspaces, workspaceMap, rootWorkspace } = findWorkspaces({
+      rootDirectory: this.rootDirectory,
+      includeRootWorkspace:
+        options.includeRootWorkspace ??
+        rootConfig.defaults.includeRootWorkspace ??
+        getUserEnvVar("includeRootWorkspaceDefault") === "true",
+    });
+    this.rootWorkspace = rootWorkspace;
+    this.workspaces = workspaces;
+    this.config = {
+      root: rootConfig,
+      workspaces: Object.fromEntries(
+        Object.entries(workspaceMap)
+          .map(([name, { config }]) => [name, config])
+          .filter(([_, config]) => config !== undefined),
+      ),
+    };
+    if (!options.name) {
+      const packageJson = JSON.parse(
+        fs.readFileSync(path.join(this.rootDirectory, "package.json"), "utf8"),
+      );
+      this.name = packageJson.name ?? "";
+    } else {
+      this.name = "";
+    }
+  }
+  runWorkspaceScript(options) {
+    validateJSTypes(
+      {
+        "workspaceNameOrAlias option": {
+          value: options.workspaceNameOrAlias,
+          typeofName: "string",
+        },
+        "script option": {
+          value: options.script,
+          typeofName: "string",
+        },
+        "inline option": {
+          value: options.inline,
+          typeofName: ["boolean", "object"],
+          optional: true,
+        },
+        "args option": {
+          value: options.args,
+          typeofName: "string",
+          optional: true,
+        },
+        "ignoreOutput option": {
+          value: options.ignoreOutput,
+          typeofName: "boolean",
+          optional: true,
+        },
+      },
+      {
+        throw: true,
+      },
+    );
+    if (isPlainObject(options.inline)) {
+      validateJSTypes(
+        {
+          "inline.scriptName option": {
+            value: options.inline.scriptName,
+            typeofName: "string",
+            optional: true,
+          },
+          "inline.shell option": {
+            value: options.inline.shell,
+            typeofName: "string",
+            optional: true,
+          },
+        },
+        {
+          throw: true,
+        },
+      );
+    }
+    const workspace = resolveRootWorkspaceSelector(
+      options.workspaceNameOrAlias,
+      this,
+    );
+    if (!workspace) {
+      throw new PROJECT_ERRORS.ProjectWorkspaceNotFound(
+        `Workspace not found: ${JSON.stringify(options.workspaceNameOrAlias)}`,
+      );
+    }
+    const shell = resolveScriptShell(
+      options.inline && typeof options.inline === "object"
+        ? options.inline.shell
+        : this.config.root.defaults.shell,
+    );
+    logger.debug(
+      `Running script ${options.inline ? "inline command" : options.script} in workspace ${workspace.name}${options.inline ? ` using the ${shell} shell` : ""}`,
+    );
+    const inlineScriptName =
+      typeof options.inline === "object"
+        ? (options.inline?.scriptName ?? "")
+        : "";
+    const scriptRuntimeMetadata = {
+      projectPath: this.rootDirectory,
+      projectName: this.name,
+      workspacePath: resolveWorkspacePath(this, workspace),
+      workspaceRelativePath: workspace.path,
+      workspaceName: workspace.name,
+      scriptName: options.inline ? inlineScriptName : options.script,
+    };
+    const args = interpolateScriptRuntimeMetadata(
+      options.args ?? "",
+      scriptRuntimeMetadata,
+      shell,
+    );
+    const script = options.inline
+      ? interpolateScriptRuntimeMetadata(
+          options.script,
+          scriptRuntimeMetadata,
+          shell,
+        ) + (args ? " " + args : "")
+      : options.script;
+    if (!options.inline && checkIsRecursiveScript(workspace.name, script)) {
+      throw new PROJECT_ERRORS.RecursiveWorkspaceScript(
+        `Script "${script}" recursively calls itself in workspace "${workspace.name}"`,
+      );
+    }
+    const scriptCommand = options.inline
+      ? {
+          command: script,
+          workingDirectory: resolveWorkspacePath(this, workspace),
+        }
+      : this.createScriptCommand({
+          workspaceNameOrAlias: options.workspaceNameOrAlias,
+          scriptName: script,
+          args,
+        }).commandDetails;
+    const result = runScript({
+      scriptCommand,
+      metadata: {
+        workspace,
+      },
+      env: createScriptRuntimeEnvVars(scriptRuntimeMetadata),
+      shell,
+      ignoreOutput: options.ignoreOutput ?? false,
+    });
+    return result;
+  }
+  runScriptAcrossWorkspaces(options) {
+    validateJSTypes(
+      {
+        "script option": {
+          value: options.script,
+          typeofName: "string",
+        },
+        "workspacePatterns option": {
+          value: options.workspacePatterns,
+          optional: true,
+          itemOptions: {
+            typeofName: "string",
+          },
+          array: true,
+        },
+        "inline option": {
+          value: options.inline,
+          typeofName: ["boolean", "object"],
+          optional: true,
+        },
+        "args option": {
+          value: options.args,
+          typeofName: "string",
+          optional: true,
+        },
+        "parallel option": {
+          value: options.parallel,
+          typeofName: ["boolean", "object"],
+          optional: true,
+        },
+        "dependencyOrder option": {
+          value: options.dependencyOrder,
+          typeofName: "boolean",
+          optional: true,
+        },
+        "ignoreDependencyFailure option": {
+          value: options.ignoreDependencyFailure,
+          typeofName: "boolean",
+          optional: true,
+        },
+        "ignoreOutput option": {
+          value: options.ignoreOutput,
+          typeofName: "boolean",
+          optional: true,
+        },
+        "onScriptEvent option": {
+          value: options.onScriptEvent,
+          typeofName: "function",
+          optional: true,
+        },
+      },
+      {
+        throw: true,
+      },
+    );
+    if (isPlainObject(options.inline)) {
+      validateJSTypes(
+        {
+          "inline.scriptName option": {
+            value: options.inline.scriptName,
+            typeofName: "string",
+            optional: true,
+          },
+          "inline.shell option": {
+            value: options.inline.shell,
+            typeofName: "string",
+            optional: true,
+          },
+        },
+        {
+          throw: true,
+        },
+      );
+    }
+    if (isPlainObject(options.parallel)) {
+      validateJSTypes(
+        {
+          "parallel.max option": {
+            value: options.parallel.max,
+            typeofName: ["number", "string"],
+          },
+        },
+        {
+          throw: true,
+        },
+      );
+    }
+    const matchedWorkspaces = sortWorkspaces(
+      (
+        options.workspacePatterns ??
+        this.workspaces.map((workspace) => workspace.name)
+      ).flatMap((pattern) => this.findWorkspacesByPattern(pattern)),
+    );
+    let workspaces = matchedWorkspaces
+      .filter(
+        (workspace) =>
+          options.inline || workspace.scripts.includes(options.script),
+      )
+      .sort((a, b) => {
+        const aScriptConfig =
+          this.config.workspaces[a.name]?.scripts[options.script];
+        const bScriptConfig =
+          this.config.workspaces[b.name]?.scripts[options.script];
+        if (!aScriptConfig) {
+          return bScriptConfig ? 1 : 0;
+        }
+        if (!bScriptConfig) {
+          return aScriptConfig ? -1 : 0;
+        }
+        return (aScriptConfig.order ?? 0) - (bScriptConfig.order ?? 0);
+      });
+    if (!workspaces.length) {
+      const isSingleMatchNotFound =
+        options.workspacePatterns?.length === 1 &&
+        !options.workspacePatterns[0].includes("*") &&
+        !matchedWorkspaces.length;
+      throw new PROJECT_ERRORS.ProjectWorkspaceNotFound(
+        isSingleMatchNotFound
+          ? `Workspace name or alias not found: ${JSON.stringify(options?.workspacePatterns?.[0])}`
+          : `No matching workspaces found with script ${JSON.stringify(options.script)}`,
+      );
+    }
+    if (options.dependencyOrder) {
+      const cycleDetection = preventDependencyCycles(workspaces);
+      workspaces = cycleDetection.workspaces;
+      for (const cycle of cycleDetection.cycles) {
+        logger.warn(
+          `Dependency cycle detected: ${cycle.dependency} -> ${cycle.dependent} (ignoring)`,
+        );
+      }
+    }
+    const recursiveWorkspace = workspaces.find((workspace) =>
+      checkIsRecursiveScript(workspace.name, options.script),
+    );
+    if (recursiveWorkspace && !options.inline) {
+      throw new PROJECT_ERRORS.RecursiveWorkspaceScript(
+        `Script "${options.script}" recursively calls itself in workspace "${recursiveWorkspace.name}"`,
+      );
+    }
+    const shell = resolveScriptShell(
+      options.inline && typeof options.inline === "object"
+        ? options.inline.shell
+        : this.config.root.defaults.shell,
+    );
+    logger.debug(
+      `Running script ${options.inline ? "inline command" : options.script} across workspaces${options.inline ? ` using the ${shell} shell` : ""}: ${workspaces.map((workspace) => workspace.name).join(", ")}`,
+    );
+    const result = runScripts({
+      scripts: workspaces.map((workspace) => {
+        const inlineScriptName =
+          typeof options.inline === "object"
+            ? (options.inline?.scriptName ?? "")
+            : "";
+        const scriptRuntimeMetadata = {
+          projectPath: this.rootDirectory,
+          projectName: this.name,
+          workspacePath: resolveWorkspacePath(this, workspace),
+          workspaceRelativePath: workspace.path,
+          workspaceName: workspace.name,
+          scriptName: options.inline ? inlineScriptName : options.script,
+        };
+        const args = interpolateScriptRuntimeMetadata(
+          options.args ?? "",
+          scriptRuntimeMetadata,
+          shell,
+        );
+        const script = options.inline
+          ? interpolateScriptRuntimeMetadata(
+              options.script,
+              scriptRuntimeMetadata,
+              shell,
+            ) + (args ? " " + args : "")
+          : options.script;
+        const scriptCommand = options.inline
+          ? {
+              command: script,
+              workingDirectory: resolveWorkspacePath(this, workspace),
+            }
+          : this.createScriptCommand({
+              workspaceNameOrAlias:
+                workspace.name === this.rootWorkspace.name
+                  ? ROOT_WORKSPACE_SELECTOR
+                  : workspace.name,
+              scriptName: script,
+              args,
+            }).commandDetails;
+        return {
+          metadata: {
+            workspace,
+          },
+          scriptCommand,
+          env: createScriptRuntimeEnvVars(scriptRuntimeMetadata),
+          shell,
+          dependsOn: options.dependencyOrder
+            ? workspace.dependencies
+                .map((dependency) =>
+                  workspaces.findIndex((w) => w.name === dependency),
+                )
+                .filter((index) => index !== -1)
+            : undefined,
+        };
+      }),
+      ignoreDependencyFailure: options.ignoreDependencyFailure,
+      parallel:
+        options.parallel === true || options.parallel === undefined
+          ? {
+              max: this.config.root.defaults.parallelMax,
+            }
+          : (options.parallel ?? true),
+      ignoreOutput: options.ignoreOutput ?? false,
+      onScriptEvent: (event, index, exitResult) =>
+        options.onScriptEvent?.(event, {
+          workspace: workspaces[index],
+          exitResult,
+        }),
+    });
+    return {
+      ...result,
+      workspaces,
+    };
+  }
+  static #initialized = false;
+}
+/**
+ * Create a {@link Project} based on a given root directory.
+ * Automatically finds workspaces based on the root package.json "workspaces" field
+ * and detects and utilizes any provided configuration.
+ */ const createFileSystemProject = (options = {}) =>
+  new _FileSystemProject(options);
+
+export { createFileSystemProject };

package/src/project/implementations/memoryProject.d.ts

@@ -0,0 +1,41 @@
+import type { Simplify } from "../../internal/core";
+import { type Workspace } from "../../workspaces";
+import type { Project } from "../project";
+import { ProjectBase } from "./projectBase";
+/** Arguments for {@link createMemoryProject} */
+export type CreateMemoryProjectOptions = {
+  /** The list of workspaces in the project */
+  workspaces: Workspace[];
+  /** The name of the project */
+  name?: string;
+  /** The root directory of the project (not used in any actual file system interactions in a {@link MemoryProject}) */
+  rootDirectory?: string;
+  /** The root workspace */
+  rootWorkspace?: Workspace;
+  /** Whether to include the root workspace as a normal workspace. */
+  includeRootWorkspace?: boolean;
+};
+declare class _MemoryProject extends ProjectBase implements Project {
+  readonly rootDirectory: string;
+  readonly workspaces: Workspace[];
+  readonly name: string;
+  readonly sourceType = "memory";
+  readonly config: {
+    root: import("../../config").ResolvedRootConfig;
+    workspaces: {};
+  };
+  readonly rootWorkspace: Workspace;
+  constructor(options: CreateMemoryProjectOptions);
+}
+/**
+ * An implementation of {@link Project} that is created from a list of workspaces in memory.
+ *
+ * Mainly used for testing without needing a real file system project. */
+export type MemoryProject = Simplify<InstanceType<typeof _MemoryProject>>;
+/** Create a {@link Project} from a provided list of workspace objects.
+ *
+ * Mainly used for testing without needing a real file system project. */
+export declare const createMemoryProject: (
+  options: CreateMemoryProjectOptions,
+) => MemoryProject;
+export {};

package/src/project/implementations/memoryProject.mjs

@@ -0,0 +1,148 @@
+import { createDefaultRootConfig } from "../../config/index.mjs";
+import { validateJSTypes } from "../../internal/core/index.mjs";
+import {
+  WORKSPACE_ERRORS,
+  validateWorkspaceAliases,
+} from "../../workspaces/index.mjs";
+import { ProjectBase } from "./projectBase.mjs"; // CONCATENATED MODULE: external "../../config/index.mjs"
+// CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../../workspaces/index.mjs"
+// CONCATENATED MODULE: external "./projectBase.mjs"
+// CONCATENATED MODULE: ./src/project/implementations/memoryProject.ts
+
+class _MemoryProject extends ProjectBase {
+  rootDirectory;
+  workspaces;
+  name;
+  sourceType = "memory";
+  config = {
+    root: createDefaultRootConfig(),
+    workspaces: {},
+  };
+  rootWorkspace;
+  constructor(options) {
+    super(true);
+    validateJSTypes(
+      {
+        "workspaces option": {
+          value: options.workspaces,
+          itemOptions: {
+            typeofName: "object",
+          },
+          array: true,
+        },
+        "name option": {
+          value: options.name,
+          typeofName: "string",
+          optional: true,
+        },
+        "rootDirectory option": {
+          value: options.rootDirectory,
+          typeofName: "string",
+          optional: true,
+        },
+        "rootWorkspace option": {
+          value: options.rootWorkspace,
+          typeofName: "object",
+          optional: true,
+        },
+        "includeRootWorkspace option": {
+          value: options.includeRootWorkspace,
+          typeofName: "boolean",
+          optional: true,
+        },
+      },
+      {
+        throw: true,
+      },
+    );
+    const validateWorkspace = (workspace) =>
+      validateJSTypes(
+        {
+          "workspace name": {
+            value: workspace.name,
+            typeofName: "string",
+          },
+          "workspace path": {
+            value: workspace.path,
+            typeofName: "string",
+          },
+          "workspace scripts": {
+            value: workspace.scripts,
+            array: true,
+            itemOptions: {
+              typeofName: "string",
+            },
+          },
+          "workspace aliases": {
+            value: workspace.aliases,
+            array: true,
+            itemOptions: {
+              typeofName: "string",
+            },
+          },
+          "workspace dependencies": {
+            value: workspace.dependencies,
+            array: true,
+            itemOptions: {
+              typeofName: "string",
+            },
+          },
+          "workspace dependents": {
+            value: workspace.dependents,
+            array: true,
+            itemOptions: {
+              typeofName: "string",
+            },
+          },
+        },
+        {
+          throw: true,
+        },
+      );
+    for (const workspace of options.workspaces) {
+      validateWorkspace(workspace);
+    }
+    this.name = options.name ?? "";
+    this.rootDirectory = options.rootDirectory ?? "";
+    this.workspaces = options.workspaces;
+    this.rootWorkspace = options.rootWorkspace ?? {
+      name: "default-root-workspace",
+      isRoot: true,
+      matchPattern: "",
+      path: "",
+      scripts: [],
+      aliases: [],
+      dependencies: [],
+      dependents: [],
+    };
+    validateWorkspace(this.rootWorkspace);
+    for (const workspace of this.workspaces) {
+      if (
+        this.workspaces.find(
+          (ws) => ws !== workspace && ws.name === workspace.name,
+        )
+      ) {
+        throw new WORKSPACE_ERRORS.DuplicateWorkspaceName(
+          `Duplicate workspace name found: ${JSON.stringify(workspace.name)}`,
+        );
+      }
+    }
+    validateWorkspaceAliases(
+      this.workspaces,
+      this.workspaces.reduce((acc, workspace) => {
+        for (const alias of workspace.aliases) {
+          acc[alias] = workspace.name;
+        }
+        return acc;
+      }, {}),
+      this.name,
+    );
+  }
+}
+/** Create a {@link Project} from a provided list of workspace objects.
+ *
+ * Mainly used for testing without needing a real file system project. */ const createMemoryProject =
+  (options) => new _MemoryProject(options);
+
+export { createMemoryProject };

package/src/project/implementations/projectBase.d.ts

@@ -0,0 +1,35 @@
+import { type Workspace } from "../../workspaces";
+import type {
+  CreateProjectScriptCommandOptions,
+  CreateProjectScriptCommandResult,
+  Project,
+  ProjectConfig,
+  WorkspaceScriptMetadata,
+} from "../project";
+export declare const resolveWorkspacePath: (
+  project: Project,
+  workspace: Workspace,
+) => string;
+export declare const ROOT_WORKSPACE_SELECTOR = "@root";
+export declare const resolveRootWorkspaceSelector: (
+  workspacePattern: string,
+  project: Project,
+) => Workspace | null;
+export declare abstract class ProjectBase implements Project {
+  abstract readonly name: string;
+  abstract readonly rootDirectory: string;
+  abstract readonly rootWorkspace: Workspace;
+  abstract readonly workspaces: Workspace[];
+  abstract readonly sourceType: "fileSystem" | "memory";
+  abstract readonly config: ProjectConfig;
+  constructor(_ignoreBunVersion?: boolean);
+  listWorkspacesWithScript(scriptName: string): Workspace[];
+  mapScriptsToWorkspaces(): Record<string, WorkspaceScriptMetadata>;
+  findWorkspaceByName(workspaceName: string): Workspace | null;
+  findWorkspaceByAlias(alias: string): Workspace | null;
+  findWorkspaceByNameOrAlias(nameOrAlias: string): Workspace | null;
+  findWorkspacesByPattern(...workspacePatterns: string[]): Workspace[];
+  createScriptCommand(
+    options: CreateProjectScriptCommandOptions,
+  ): CreateProjectScriptCommandResult;
+}