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

package/src/runScript/scriptRuntimeMetadata.mjs

@@ -0,0 +1,62 @@
+import { IS_WINDOWS } from "../internal/runtime/index.mjs"; // CONCATENATED MODULE: external "../internal/runtime/index.mjs"
+// CONCATENATED MODULE: ./src/runScript/scriptRuntimeMetadata.ts
+
+const SCRIPT_RUNTIME_METADATA_CONFIG = {
+  projectPath: {
+    inlineName: ["<projectPath>"],
+    envVarName: "BW_PROJECT_PATH",
+  },
+  projectName: {
+    inlineName: ["<projectName>"],
+    envVarName: "BW_PROJECT_NAME",
+  },
+  workspacePath: {
+    inlineName: ["<workspacePath>"],
+    envVarName: "BW_WORKSPACE_PATH",
+  },
+  workspaceRelativePath: {
+    inlineName: ["<workspaceRelativePath>"],
+    envVarName: "BW_WORKSPACE_RELATIVE_PATH",
+  },
+  scriptName: {
+    inlineName: ["<scriptName>"],
+    envVarName: "BW_SCRIPT_NAME",
+  },
+  workspaceName: {
+    /** @todo  @deprecated Deprecate <workspace> in favor of <workspaceName> in major release */ inlineName:
+      ["<workspaceName>", "<workspace>"],
+    envVarName: "BW_WORKSPACE_NAME",
+  },
+};
+const getScriptRuntimeMetadataConfig = (key) =>
+  SCRIPT_RUNTIME_METADATA_CONFIG[key];
+const createScriptRuntimeEnvVars = (metadata) =>
+  Object.entries(SCRIPT_RUNTIME_METADATA_CONFIG).reduce((acc, [key, value]) => {
+    acc[value.envVarName] = metadata[key];
+    return acc;
+  }, {});
+const interpolateScriptRuntimeMetadata = (text, metadata, shell) =>
+  text.replace(
+    new RegExp(
+      Object.values(SCRIPT_RUNTIME_METADATA_CONFIG)
+        .flatMap((value) => value.inlineName)
+        .join("|"),
+      "g",
+    ),
+    (match) => {
+      const key = Object.entries(SCRIPT_RUNTIME_METADATA_CONFIG).find(
+        ([_, value]) => value.inlineName.includes(match),
+      )?.[0];
+      const value = metadata[key];
+      if (IS_WINDOWS && shell === "bun") {
+        return value.replace(/\\/g, "\\\\");
+      }
+      return value;
+    },
+  );
+
+export {
+  createScriptRuntimeEnvVars,
+  getScriptRuntimeMetadataConfig,
+  interpolateScriptRuntimeMetadata,
+};

package/src/runScript/scriptShellOption.d.ts

@@ -0,0 +1,7 @@
+export declare const SCRIPT_SHELL_OPTIONS: readonly ["bun", "system"];
+export type ScriptShellOption = (typeof SCRIPT_SHELL_OPTIONS)[number];
+export declare const validateScriptShellOption: (
+  shell: string,
+) => ScriptShellOption;
+export declare const getScriptShellDefault: () => "bun" | "system";
+export declare const resolveScriptShell: (shell?: string) => ScriptShellOption;

package/src/runScript/scriptShellOption.mjs

@@ -0,0 +1,36 @@
+import { getUserEnvVar } from "../config/userEnvVars.mjs";
+import { BunWorkspacesError } from "../internal/core/index.mjs"; // CONCATENATED MODULE: external "../config/userEnvVars.mjs"
+// CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/runScript/scriptShellOption.ts
+
+const SCRIPT_SHELL_OPTIONS = ["bun", "system"];
+const validateScriptShellOption = (shell) => {
+  if (!SCRIPT_SHELL_OPTIONS.includes(shell)) {
+    throw new BunWorkspacesError(
+      `Invalid shell option: ${shell} (accepted values: ${SCRIPT_SHELL_OPTIONS.join(", ")})`,
+    );
+  }
+  return shell;
+};
+const getScriptShellDefault = () => {
+  const shell = getUserEnvVar("scriptShellDefault");
+  return shell ? validateScriptShellOption(shell) : "bun";
+};
+const resolveScriptShell = (shell) => {
+  if (
+    !shell ||
+    shell === "default" ||
+    shell === "undefined" ||
+    shell === "null"
+  ) {
+    return getScriptShellDefault();
+  }
+  return validateScriptShellOption(shell);
+};
+
+export {
+  SCRIPT_SHELL_OPTIONS,
+  getScriptShellDefault,
+  resolveScriptShell,
+  validateScriptShellOption,
+};

package/src/workspaces/errors.d.ts

@@ -0,0 +1,12 @@
+export declare const WORKSPACE_ERRORS: import("../internal/core").DefinedErrors<
+  | "PackageNotFound"
+  | "InvalidPackageJson"
+  | "DuplicateWorkspaceName"
+  | "InvalidWorkspaceName"
+  | "NoWorkspaceName"
+  | "InvalidScripts"
+  | "InvalidWorkspaces"
+  | "InvalidWorkspacePattern"
+  | "AliasConflict"
+  | "AliasedWorkspaceNotFound"
+>;

package/src/workspaces/{errors.ts → errors.mjs}

@@ -1,6 +1,7 @@
-import { defineErrors } from "../internal/error";
+import { defineErrors } from "../internal/core/index.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/workspaces/errors.ts
 
-export const ERRORS = defineErrors(
+const WORKSPACE_ERRORS = defineErrors(
   "PackageNotFound",
   "InvalidPackageJson",
   "DuplicateWorkspaceName",
@@ -12,3 +13,5 @@ export const ERRORS = defineErrors(
   "AliasConflict",
   "AliasedWorkspaceNotFound",
 );
+
+export { WORKSPACE_ERRORS };

package/src/workspaces/findWorkspaces.d.ts

@@ -0,0 +1,22 @@
+import { type ProjectConfig, type ResolvedWorkspaceConfig } from "../config";
+import type { Workspace } from "./workspace";
+export interface FindWorkspacesOptions {
+  rootDirectory: string;
+  /** If provided, will override the workspaces found in the package.json. Mainly for testing purposes */
+  workspaceGlobs?: string[];
+  /** @deprecated due to config file changes */
+  workspaceAliases?: ProjectConfig["workspaceAliases"];
+}
+export declare const sortWorkspaces: (workspaces: Workspace[]) => Workspace[];
+export declare const findWorkspaces: ({
+  rootDirectory,
+  workspaceGlobs: _workspaceGlobs,
+  workspaceAliases,
+}: FindWorkspacesOptions) => {
+  workspaces: Workspace[];
+  workspaceConfigMap: Record<string, ResolvedWorkspaceConfig>;
+};
+export declare const validateWorkspaceAliases: (
+  workspaces: Workspace[],
+  workspaceAliases: ProjectConfig["workspaceAliases"],
+) => void;

package/src/workspaces/findWorkspaces.mjs

@@ -0,0 +1,168 @@
+import fs from "fs";
+import path from "path";
+import { Glob } from "bun";
+import {
+  createWorkspaceConfig,
+  loadWorkspaceConfig,
+} from "../config/index.mjs";
+import { BUN_LOCK_ERRORS, readBunLockfile } from "../internal/bun/index.mjs";
+import { BunWorkspacesError } from "../internal/core/index.mjs";
+import { WORKSPACE_ERRORS } from "./errors.mjs";
+import {
+  resolvePackageJsonContent,
+  resolvePackageJsonPath,
+} from "./packageJson.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "bun"
+// CONCATENATED MODULE: external "../config/index.mjs"
+// CONCATENATED MODULE: external "../internal/bun/index.mjs"
+// CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: external "./packageJson.mjs"
+// CONCATENATED MODULE: ./src/workspaces/findWorkspaces.ts
+
+const sortWorkspaces = (workspaces) =>
+  [...workspaces]
+    .sort(
+      (a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path),
+    )
+    .reduce((acc, workspace, i, arr) => {
+      const previousWorkspace = arr[i - 1];
+      if (previousWorkspace && previousWorkspace.path === workspace.path) {
+        return acc;
+      }
+      return [...acc, workspace];
+    }, []);
+const getWorkspaceGlobsFromRoot = ({ rootDirectory }) => {
+  const packageJsonPath = path.join(rootDirectory, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new WORKSPACE_ERRORS.PackageNotFound(
+      `No package.json found for project root at ${packageJsonPath}`,
+    );
+  }
+  const packageJson = resolvePackageJsonContent(
+    packageJsonPath,
+    rootDirectory,
+    ["workspaces"],
+  );
+  return packageJson.workspaces ?? [];
+};
+const validateWorkspace = (workspace, workspaces) => {
+  if (workspaces.find((ws) => ws.path === workspace.path)) {
+    return false;
+  }
+  if (workspaces.find((ws) => ws.name === workspace.name)) {
+    throw new WORKSPACE_ERRORS.DuplicateWorkspaceName(
+      `Duplicate workspace name found: ${JSON.stringify(workspace.name)}`,
+    );
+  }
+  return true;
+};
+const findWorkspaces = ({
+  rootDirectory,
+  workspaceGlobs: _workspaceGlobs,
+  workspaceAliases = {},
+}) => {
+  rootDirectory = path.resolve(rootDirectory);
+  let workspaces = [];
+  const excludedWorkspacePaths = [];
+  const workspaceConfigMap = {};
+  const bunLock = readBunLockfile(rootDirectory);
+  if (bunLock instanceof BunWorkspacesError) {
+    if (bunLock instanceof BUN_LOCK_ERRORS.BunLockNotFound) {
+      bunLock.message =
+        `No bun.lock found at ${rootDirectory}. Check that this is the directory of your project and that you've ran 'bun install'.` +
+        "If you have ran 'bun install', you may simply have no workspaces or dependencies in your project.";
+    }
+    throw bunLock;
+  }
+  const workspaceGlobs =
+    _workspaceGlobs ??
+    getWorkspaceGlobsFromRoot({
+      rootDirectory,
+    });
+  for (const workspacePath of Object.keys(bunLock.workspaces).map((p) =>
+    path.join(rootDirectory, p),
+  )) {
+    if (workspacePath === rootDirectory) {
+      continue;
+    }
+    const packageJsonPath = resolvePackageJsonPath(workspacePath);
+    if (packageJsonPath) {
+      const packageJsonContent = resolvePackageJsonContent(
+        packageJsonPath,
+        rootDirectory,
+        ["name", "scripts"],
+      );
+      const workspaceConfig = loadWorkspaceConfig(
+        path.dirname(packageJsonPath),
+      );
+      if (workspaceConfig) {
+        for (const alias of workspaceConfig.aliases) {
+          workspaceAliases[alias] = packageJsonContent.name;
+        }
+      }
+      const relativePath = path.relative(
+        rootDirectory,
+        path.dirname(packageJsonPath),
+      );
+      const matchPattern =
+        workspaceGlobs.find((glob) => new Glob(glob).match(relativePath)) ?? "";
+      if (_workspaceGlobs && !matchPattern) {
+        continue;
+      }
+      const workspace = {
+        name: packageJsonContent.name ?? "",
+        matchPattern,
+        path: path.relative(rootDirectory, path.dirname(packageJsonPath)),
+        scripts: Object.keys(packageJsonContent.scripts ?? {}).sort(),
+        aliases: [
+          ...new Set(
+            Object.entries(workspaceAliases ?? {})
+              .filter(([_, value]) => value === packageJsonContent.name)
+              .map(([key]) => key)
+              .concat(workspaceConfig?.aliases ?? []),
+          ),
+        ],
+      };
+      if (
+        !excludedWorkspacePaths.includes(workspace.path) &&
+        validateWorkspace(workspace, workspaces)
+      ) {
+        workspaces.push(workspace);
+        workspaceConfigMap[workspace.name] =
+          workspaceConfig ?? createWorkspaceConfig();
+      }
+    }
+  }
+  workspaces = sortWorkspaces(workspaces);
+  validateWorkspaceAliases(workspaces, workspaceAliases);
+  return {
+    workspaces,
+    workspaceConfigMap,
+  };
+};
+const validateWorkspaceAliases = (workspaces, workspaceAliases) => {
+  for (const [alias, name] of Object.entries(workspaceAliases ?? {})) {
+    if (workspaces.find((ws) => ws.name === alias)) {
+      throw new WORKSPACE_ERRORS.AliasConflict(
+        `Alias ${JSON.stringify(alias)} conflicts with workspace name ${JSON.stringify(name)}`,
+      );
+    }
+    const workspaceWithDuplicateAlias = workspaces.find(
+      (ws) => ws.name !== name && ws.aliases.includes(alias),
+    );
+    if (workspaceWithDuplicateAlias) {
+      throw new WORKSPACE_ERRORS.AliasConflict(
+        `Workspaces ${JSON.stringify(name)} and ${JSON.stringify(workspaceWithDuplicateAlias.name)} have the same alias ${JSON.stringify(alias)}`,
+      );
+    }
+    if (!workspaces.find((ws) => ws.name === name)) {
+      throw new WORKSPACE_ERRORS.AliasedWorkspaceNotFound(
+        `Workspace ${JSON.stringify(name)} was aliased by ${JSON.stringify(alias)} but was not found`,
+      );
+    }
+  }
+};
+
+export { findWorkspaces, sortWorkspaces, validateWorkspaceAliases };

package/src/workspaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./findWorkspaces";
+export * from "./packageJson";
+export * from "./errors";
+export type * from "./workspace";

package/src/workspaces/index.mjs

@@ -0,0 +1,3 @@
+export * from "./findWorkspaces.mjs";
+export * from "./packageJson.mjs";
+export * from "./errors.mjs"; // CONCATENATED MODULE: ./src/workspaces/index.ts

package/src/workspaces/packageJson.d.ts

@@ -0,0 +1,15 @@
+export declare const resolvePackageJsonPath: (directoryItem: string) => string;
+export type ResolvedPackageJsonContent = {
+  name: string;
+  workspaces: string[];
+  scripts: Record<string, string>;
+} & Record<string, unknown>;
+export declare const scanWorkspaceGlob: (
+  globPattern: string,
+  rootDirectory: string,
+) => IterableIterator<string>;
+export declare const resolvePackageJsonContent: (
+  packageJsonPath: string,
+  rootDirectory: string,
+  validations: ("workspaces" | "name" | "scripts")[],
+) => ResolvedPackageJsonContent;

package/src/workspaces/packageJson.mjs

@@ -0,0 +1,135 @@
+import fs from "fs";
+import path from "path";
+import { Glob } from "bun";
+import { logger } from "../internal/logger/index.mjs";
+import { WORKSPACE_ERRORS } from "./errors.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "bun"
+// CONCATENATED MODULE: external "../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: ./src/workspaces/packageJson.ts
+
+const resolvePackageJsonPath = (directoryItem) => {
+  if (path.basename(directoryItem) === "package.json") {
+    return directoryItem;
+  }
+  if (fs.existsSync(path.join(directoryItem, "package.json"))) {
+    return path.join(directoryItem, "package.json");
+  }
+  return "";
+};
+const scanWorkspaceGlob = (globPattern, rootDirectory) =>
+  new Glob(globPattern).scanSync({
+    cwd: rootDirectory,
+    absolute: true,
+    onlyFiles: false,
+  });
+const validateJsonRoot = (json) => {
+  if (!json || typeof json !== "object" || Array.isArray(json)) {
+    throw new WORKSPACE_ERRORS.InvalidPackageJson(
+      `Expected package.json to be an object, got ${typeof json}`,
+    );
+  }
+};
+const validateName = (json) => {
+  if (typeof json.name !== "string") {
+    throw new WORKSPACE_ERRORS.NoWorkspaceName(
+      `Expected package.json to have a string "name" field${json.name !== undefined ? ` (Received ${json.name})` : ""}`,
+    );
+  }
+  if (!json.name.trim()) {
+    throw new WORKSPACE_ERRORS.NoWorkspaceName(
+      `Expected package.json to have a non-empty "name" field`,
+    );
+  }
+  if (json.name.includes("*")) {
+    throw new WORKSPACE_ERRORS.InvalidWorkspaceName(
+      `Package name cannot contain the character '*' (workspace: "${json.name}")`,
+    );
+  }
+  return json.name;
+};
+const validateWorkspacePattern = (workspacePattern, rootDirectory) => {
+  if (typeof workspacePattern !== "string") {
+    throw new WORKSPACE_ERRORS.InvalidWorkspacePattern(
+      `Expected workspace pattern to be a string, got ${typeof workspacePattern}`,
+    );
+  }
+  if (!workspacePattern.trim()) {
+    return false;
+  }
+  const absolutePattern = path.resolve(rootDirectory, workspacePattern);
+  if (!absolutePattern.startsWith(rootDirectory)) {
+    throw new WORKSPACE_ERRORS.InvalidWorkspacePattern(
+      `Cannot resolve workspace pattern outside of root directory ${rootDirectory}: ${absolutePattern}`,
+    );
+  }
+  return true;
+};
+const validateWorkspacePatterns = (json, rootDirectory) => {
+  const workspaces = [];
+  if (json.workspaces) {
+    if (!Array.isArray(json.workspaces)) {
+      throw new WORKSPACE_ERRORS.InvalidWorkspaces(
+        `Expected package.json to have an array "workspaces" field`,
+      );
+    }
+    for (const workspacePattern of json.workspaces) {
+      if (validateWorkspacePattern(workspacePattern, rootDirectory)) {
+        workspaces.push(workspacePattern);
+      }
+    }
+  }
+  return workspaces;
+};
+const validateScripts = (json) => {
+  if (
+    json.scripts &&
+    (typeof json.scripts !== "object" || Array.isArray(json.scripts))
+  ) {
+    throw new WORKSPACE_ERRORS.InvalidScripts(
+      `Expected package.json to have an object "scripts" field`,
+    );
+  }
+  if (json.scripts) {
+    for (const value of Object.values(json.scripts)) {
+      if (typeof value !== "string") {
+        throw new WORKSPACE_ERRORS.InvalidScripts(
+          `Expected workspace "${json.name}" script "${json.scripts}" to be a string, got ${typeof value}`,
+        );
+      }
+    }
+  }
+  return {
+    ...json.scripts,
+  };
+};
+const resolvePackageJsonContent = (
+  packageJsonPath,
+  rootDirectory,
+  validations,
+) => {
+  rootDirectory = path.resolve(rootDirectory);
+  let json = {};
+  try {
+    json = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  } catch (error) {
+    logger.error(error);
+    throw new WORKSPACE_ERRORS.InvalidPackageJson(
+      `Failed to read and parse package.json at ${packageJsonPath}: ${error.message}`,
+    );
+  }
+  validateJsonRoot(json);
+  return {
+    ...json,
+    name: validations.includes("name") ? validateName(json) : (json.name ?? ""),
+    workspaces: validations.includes("workspaces")
+      ? validateWorkspacePatterns(json, rootDirectory)
+      : (json?.workspaces ?? []),
+    scripts: validations.includes("scripts")
+      ? validateScripts(json)
+      : (json.scripts ?? {}),
+  };
+};
+
+export { resolvePackageJsonContent, resolvePackageJsonPath, scanWorkspaceGlob };

package/src/workspaces/{workspace.ts → workspace.d.ts}

@@ -1,14 +1,13 @@
-import type { ResolvedPackageJsonContent } from "./packageJson";
-
-export interface Workspace {
+/** Metadata about a nested package within a Bun monorepo */
+export type Workspace = {
   /** The name of the workspace from its `package.json` */
   name: string;
   /** The relative path to the workspace from the root `package.json` */
   path: string;
   /** The pattern from `"workspaces"` in the root `package.json`that this workspace was matched from*/
   matchPattern: string;
-  /** The contents of the workspace's package.json, with `"workspaces"` and `"scripts"` resolved */
-  packageJson: ResolvedPackageJsonContent;
+  /** The scripts available in package.json */
+  scripts: string[];
   /** Aliases assigned to the workspace via the `"workspaceAliases"` field in the config */
   aliases: string[];
-}
+};

package/src/workspaces/workspace.mjs

@@ -0,0 +1,2 @@
+// CONCATENATED MODULE: ./src/workspaces/workspace.ts
+/** Metadata about a nested package within a Bun monorepo */