bun-workspaces 1.0.1-alpha → 1.0.1

package/src/workspaces/packageJson.mjs

@@ -0,0 +1,188 @@
+import fs from "fs";
+import path from "path";
+import { isJSONObject } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/index.mjs";
+import { WORKSPACE_ERRORS } from "./errors.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../internal/core/index.mjs"
+// 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 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 parseCatalogMap = (raw) => {
+  if (!isJSONObject(raw)) return {};
+  return Object.fromEntries(
+    Object.entries(raw).filter(([, value]) => typeof value === "string"),
+  );
+};
+const validateWorkspacePatterns = (json, rootDirectory) => {
+  const workspaces = [];
+  let catalog = {};
+  const catalogs = {};
+  if (json.workspaces) {
+    let source = "array";
+    let rawWorkspaces = [];
+    if (isJSONObject(json.workspaces)) {
+      source = "catalogObject";
+      rawWorkspaces = json.workspaces?.packages;
+      catalog = parseCatalogMap(json.workspaces.catalog);
+      if (isJSONObject(json.workspaces.catalogs)) {
+        for (const [name, value] of Object.entries(json.workspaces.catalogs)) {
+          catalogs[name] = parseCatalogMap(value);
+        }
+      }
+    } else {
+      source = "array";
+      rawWorkspaces = json.workspaces;
+    }
+    if (!Array.isArray(rawWorkspaces)) {
+      throw new WORKSPACE_ERRORS.InvalidWorkspaces(
+        `Expected package.json "workspaces${source === "catalogObject" ? ".packages" : ""}" to be an array`,
+      );
+    }
+    for (const workspacePattern of rawWorkspaces) {
+      if (validateWorkspacePattern(workspacePattern, rootDirectory)) {
+        workspaces.push(workspacePattern);
+      }
+    }
+  }
+  return {
+    workspaces,
+    catalog,
+    catalogs,
+  };
+};
+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,
+  };
+};
+/**
+ * Resolve a `catalog:` or `catalog:name` version reference for a given package name.
+ * Returns the resolved version string, or null if the catalog or package is not found.
+ */ const resolveCatalogDependencyVersion = (
+  packageName,
+  catalogRef,
+  catalogs,
+) => {
+  if (!catalogRef.startsWith("catalog:")) return null;
+  const catalogName = catalogRef.slice("catalog:".length);
+  if (!catalogName) {
+    return catalogs.defaultCatalog[packageName] ?? null;
+  }
+  return catalogs.namedCatalogs[catalogName]?.[packageName] ?? null;
+};
+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);
+  const { workspaces, catalog, catalogs } = validations.includes("workspaces")
+    ? validateWorkspacePatterns(json, rootDirectory)
+    : {
+        workspaces: json?.workspaces ?? [],
+        catalog: {},
+        catalogs: {},
+      };
+  return {
+    ...json,
+    // Dependency data types are validated by bun install
+    // TODO investigate whether we need to validate any of these fields in the first place
+    dependencies: json.dependencies ?? {},
+    devDependencies: json.devDependencies ?? {},
+    peerDependencies: json.peerDependencies ?? {},
+    optionalDependencies: json.optionalDependencies ?? {},
+    name: validations.includes("name") ? validateName(json) : (json.name ?? ""),
+    workspaces,
+    catalog,
+    catalogs,
+    scripts: validations.includes("scripts")
+      ? validateScripts(json)
+      : (json.scripts ?? {}),
+  };
+};
+
+export {
+  resolveCatalogDependencyVersion,
+  resolvePackageJsonContent,
+  resolvePackageJsonPath,
+};

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

@@ -1,14 +1,19 @@
-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;
+  /** Whether the workspace is the root workspace */
+  isRoot: boolean;
   /** 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[];
-}
+  /** Names of workspaces that this workspace depends on */
+  dependencies: string[];
+  /** Names of workspaces that depend on this workspace */
+  dependents: 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 */

package/src/workspaces/workspacePattern.d.ts

@@ -0,0 +1,21 @@
+import type { Workspace } from "./workspace";
+declare const TARGETS: readonly ["path", "alias", "name"];
+export declare const WORKSPACE_PATTERN_ERRORS: import("../internal/core").DefinedErrors<"InvalidWorkspacePattern">;
+export type WorkspacePatternTarget = (typeof TARGETS)[number];
+export type WorkspacePattern = {
+  target: WorkspacePatternTarget | "default";
+  value: string;
+  isNegated: boolean;
+};
+export declare const WORKSPACE_PATTERN_SEPARATOR = ":";
+export declare const parseWorkspacePattern: (
+  pattern: string,
+) => WorkspacePattern;
+export declare const stringifyWorkspacePattern: (
+  pattern: WorkspacePattern,
+) => string;
+export declare const matchWorkspacesByPatterns: (
+  patterns: string[],
+  workspaces: Workspace[],
+) => Workspace[];
+export {};

package/src/workspaces/workspacePattern.mjs

@@ -0,0 +1,104 @@
+import bun from "bun";
+import { createWildcardRegex, defineErrors } from "../internal/core/index.mjs"; // CONCATENATED MODULE: external "bun"
+// CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/workspaces/workspacePattern.ts
+
+const TARGETS = ["path", "alias", "name"];
+const WORKSPACE_PATTERN_ERRORS = defineErrors("InvalidWorkspacePattern");
+const WORKSPACE_PATTERN_SEPARATOR = ":";
+const parseWorkspacePattern = (pattern) => {
+  const isNegated = pattern.startsWith("!");
+  const patternValue = isNegated ? pattern.slice(1) : pattern;
+  const target = TARGETS.find((target) =>
+    patternValue.startsWith(target + WORKSPACE_PATTERN_SEPARATOR),
+  );
+  if (!target) {
+    return {
+      target: "default",
+      value: patternValue,
+      isNegated: pattern.startsWith("!"),
+    };
+  }
+  const value = patternValue.slice(
+    target.length + WORKSPACE_PATTERN_SEPARATOR.length,
+  );
+  return {
+    target,
+    value,
+    isNegated,
+  };
+};
+const stringifyWorkspacePattern = (pattern) => {
+  return `${pattern.target}${WORKSPACE_PATTERN_SEPARATOR}${pattern.value}`;
+};
+const PATTERN_TARGET_HANDLERS = {
+  default: (pattern, workspaces, wildcardRegex) => {
+    return workspaces.filter((workspace) => {
+      return (
+        (pattern.value.includes("*")
+          ? wildcardRegex.test(workspace.name)
+          : workspace.name === pattern.value) ||
+        workspace.aliases.some((alias) =>
+          pattern.value.includes("*")
+            ? wildcardRegex.test(alias)
+            : alias === pattern.value,
+        )
+      );
+    });
+  },
+  name: (pattern, workspaces, wildcardRegex) => {
+    return workspaces.filter((workspace) => {
+      return pattern.value.includes("*")
+        ? wildcardRegex.test(workspace.name)
+        : workspace.name === pattern.value;
+    });
+  },
+  alias: (pattern, workspaces, wildcardRegex) => {
+    return workspaces.filter((workspace) => {
+      return pattern.value.includes("*")
+        ? workspace.aliases.some((alias) => wildcardRegex.test(alias))
+        : workspace.aliases.includes(pattern.value);
+    });
+  },
+  path: (pattern, workspaces) => {
+    return workspaces.filter((workspace) =>
+      new bun.Glob(pattern.value).match(workspace.path),
+    );
+  },
+};
+const matchWorkspacesByPattern = (pattern, workspaces) =>
+  PATTERN_TARGET_HANDLERS[pattern.target](
+    pattern,
+    workspaces,
+    createWildcardRegex(pattern.value),
+  );
+const matchWorkspacesByPatterns = (patterns, workspaces) => {
+  const parsedPatterns = patterns.map(parseWorkspacePattern);
+  const excludePatterns = parsedPatterns.filter((pattern) => pattern.isNegated);
+  const includePatterns = parsedPatterns.filter(
+    (pattern) => !pattern.isNegated,
+  );
+  const excludeWorkspaces = excludePatterns.flatMap((pattern) =>
+    matchWorkspacesByPattern(pattern, workspaces),
+  );
+  const includeWorkspaces = includePatterns.flatMap((pattern) =>
+    matchWorkspacesByPattern(pattern, workspaces),
+  );
+  return includeWorkspaces.filter(
+    (workspace, index, arr) =>
+      !excludeWorkspaces.some(
+        (excludeWorkspace) => excludeWorkspace.name === workspace.name,
+      ) &&
+      !arr
+        .slice(index + 1)
+        .some((nextWorkspace) => nextWorkspace.name === workspace.name),
+  );
+};
+
+export {
+  WORKSPACE_PATTERN_ERRORS,
+  WORKSPACE_PATTERN_SEPARATOR,
+  matchWorkspacesByPatterns,
+  parseWorkspacePattern,
+  stringifyWorkspacePattern,
+};