bun-workspaces 1.0.1-alpha → 1.0.2

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from "./workspaces";
-export * from "./project";
-export * from "./cli";

package/src/internal/bunVersion.ts

@@ -1,26 +0,0 @@
-import rootPackageJson from "../../package.json";
-
-export const LIBRARY_CONSUMER_BUN_VERSION =
-  rootPackageJson.custom.bunVersion.libraryConsumer;
-
-export const BUILD_BUN_VERSION = rootPackageJson.custom.bunVersion.build;
-
-export const getRequiredBunVersion = (build?: boolean) =>
-  build ? BUILD_BUN_VERSION : LIBRARY_CONSUMER_BUN_VERSION;
-
-const _Bun = typeof Bun === "undefined" ? ({} as typeof Bun) : Bun;
-
-/**
- * Validates that the provided version satisfies the required Bun version
- * specified in the root `package.json`.
- */
-export const validateBunVersion = (version: string, build?: boolean) =>
-  _Bun ? _Bun.semver.satisfies(version, getRequiredBunVersion(build)) : true;
-
-/**
- *
- * Validates that the Bun version of the current script satisfies the
- * required Bun version specified in the root `package.json`.
- */
-export const validateCurrentBunVersion = (build?: boolean) =>
-  validateBunVersion(_Bun?.version, build);

package/src/internal/env.ts

@@ -1,25 +0,0 @@
-const RUNTIME_MODE_VALUES = ["development", "production", "test"] as const;
-
-export type RuntimeMode = "development" | "production" | "test";
-
-const _RUNTIME_MODE: RuntimeMode = ((process.env
-  ._BW_RUNTIME_MODE as RuntimeMode) ||
-  (process.env.NODE_ENV?.match(/test(ing)?/)
-    ? "test"
-    : process.env.NODE_ENV === "development"
-      ? "development"
-      : "production")) as RuntimeMode;
-
-export const RUNTIME_MODE = RUNTIME_MODE_VALUES.includes(_RUNTIME_MODE)
-  ? _RUNTIME_MODE
-  : "production";
-
-if (RUNTIME_MODE !== _RUNTIME_MODE) {
-  console.error(
-    `Env var RUNTIME_MODE has an invalid value: "${_RUNTIME_MODE}". Defaulting to "${RUNTIME_MODE}". Accepted values: ${RUNTIME_MODE_VALUES.join(", ")}.`,
-  );
-}
-
-export const IS_TEST = RUNTIME_MODE === "test";
-export const IS_PRODUCTION = RUNTIME_MODE === "production";
-export const IS_DEVELOPMENT = RUNTIME_MODE === "development";

package/src/internal/logger.ts

@@ -1,145 +0,0 @@
-import { IS_PRODUCTION, IS_TEST } from "./env";
-
-export const LOG_LEVELS = ["debug", "info", "warn", "error"] as const;
-
-const getLevelNumber = (level: LogLevel) => LOG_LEVELS.indexOf(level);
-
-export type LogLevel = (typeof LOG_LEVELS)[number];
-
-export type LogLevelSetting = LogLevel | "silent";
-
-export const validateLogLevel = (level: LogLevelSetting) => {
-  if (level === "silent") return;
-  if (!LOG_LEVELS.includes(level)) {
-    throw new Error(
-      `Invalid log level: "${level}". Accepted values: ${LOG_LEVELS.join(", ")}`,
-    );
-  }
-};
-
-export type LogMetadata = Record<string, any>;
-
-export interface Log<
-  Message extends string | Error = string,
-  Metadata extends LogMetadata = LogMetadata,
-> {
-  message: Message;
-  level: LogLevel;
-  metadata: Metadata;
-  time: Date;
-}
-
-export type Logger = {
-  name: string;
-
-  log<
-    Message extends string | Error = string,
-    Metadata extends LogMetadata = LogMetadata,
-  >(
-    message: Message,
-    level: LogLevel,
-    metadata?: Metadata,
-  ): Log<Message, Metadata>;
-
-  printLevel: LogLevelSetting;
-} & {
-  [Level in LogLevel]: <
-    Message extends string | Error = string,
-    Metadata extends LogMetadata = LogMetadata,
-  >(
-    message: Message,
-    metadata?: Metadata,
-  ) => Log<Message, Metadata>;
-};
-
-export const createLogger = (name: string): Logger => new _Logger(name);
-
-class _Logger implements Logger {
-  constructor(public name: string) {}
-
-  log<
-    Message extends string | Error = string,
-    Metadata extends LogMetadata = LogMetadata,
-  >(
-    message: Message,
-    level: LogLevel,
-    metadata?: Metadata,
-  ): Log<Message, Metadata> {
-    const log: Log<Message, Metadata> = {
-      message,
-      level,
-      metadata: metadata ?? ({} as Metadata),
-      time: new Date(),
-    };
-
-    if (this.shouldPrint(level)) {
-      const formattedMessage = this.formatLogMessage(message, level);
-      if (message instanceof Error) {
-        message.message = formattedMessage;
-      }
-      console[level](
-        message instanceof Error ? message : formattedMessage,
-        ...(metadata ? [{ metadata }] : []),
-      );
-    }
-
-    return log;
-  }
-
-  debug<
-    Message extends string | Error = string,
-    Metadata extends LogMetadata = LogMetadata,
-  >(message: Message, metadata?: Metadata): Log<Message, Metadata> {
-    return this.log(message, "debug", metadata);
-  }
-
-  info<
-    Message extends string | Error = string,
-    Metadata extends LogMetadata = LogMetadata,
-  >(message: Message, metadata?: Metadata): Log<Message, Metadata> {
-    return this.log(message, "info", metadata);
-  }
-
-  warn<
-    Message extends string | Error = string,
-    Metadata extends LogMetadata = LogMetadata,
-  >(message: Message, metadata?: Metadata): Log<Message, Metadata> {
-    return this.log(message, "warn", metadata);
-  }
-
-  error<
-    Message extends string | Error = string,
-    Metadata extends LogMetadata = LogMetadata,
-  >(message: Message, metadata?: Metadata): Log<Message, Metadata> {
-    return this.log(message, "error", metadata);
-  }
-
-  get printLevel() {
-    return this._printLevel;
-  }
-
-  set printLevel(level: LogLevelSetting) {
-    this._printLevel = level;
-  }
-
-  // Info prints normally for standard user-facing logs. Debug and Warn are highlighted with a prefix. Errors print as Error instances
-  private formatLogMessage(message: Error | string, level: LogLevel): string {
-    const content = message instanceof Error ? message.message : message;
-    return level === "debug" || level === "warn"
-      ? `[${this.name} ${level.toUpperCase()}]: ${content}`
-      : content;
-  }
-
-  private _printLevel: LogLevelSetting = IS_PRODUCTION
-    ? "info"
-    : IS_TEST
-      ? "silent"
-      : "debug";
-
-  private shouldPrint(level: LogLevel): boolean {
-    if (this.printLevel === "silent") return false;
-    return getLevelNumber(level) >= getLevelNumber(this.printLevel);
-  }
-}
-
-export const logger = createLogger("bun-workspaces");

package/src/internal/regex.ts

@@ -1,5 +0,0 @@
-export const createRawPattern = (pattern: string) =>
-  pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-
-export const createWildcardRegex = (pattern: string) =>
-  new RegExp(`^${pattern.split("*").map(createRawPattern).join(".*")}$`);

package/src/project/errors.ts

@@ -1,6 +0,0 @@
-import { defineErrors } from "../internal/error";
-
-export const ERRORS = defineErrors(
-  "ProjectWorkspaceNotFound",
-  "WorkspaceScriptDoesNotExist",
-);

package/src/project/index.ts

@@ -1,6 +0,0 @@
-export {
-  type Project,
-  type CreateProjectOptions,
-  type CreateProjectScriptCommandOptions,
-  createProject,
-} from "./project";

package/src/project/project.ts

@@ -1,155 +0,0 @@
-import path from "path";
-import { createWildcardRegex } from "../internal/regex";
-import { findWorkspacesFromPackage, type Workspace } from "../workspaces";
-import { ERRORS } from "./errors";
-import {
-  createScriptCommand,
-  type CreateScriptCommandOptions,
-  type ScriptCommand,
-} from "./scriptCommand";
-
-export interface ScriptMetadata {
-  name: string;
-  workspaces: Workspace[];
-}
-
-export type CreateProjectScriptCommandOptions = Omit<
-  CreateScriptCommandOptions,
-  "workspace" | "rootDir"
-> & {
-  workspaceName: string;
-};
-
-export interface CreateProjectScriptCommandResult {
-  command: ScriptCommand;
-  scriptName: string;
-  workspace: Workspace;
-}
-
-export interface Project {
-  name: string;
-  rootDir: string;
-  workspaces: Workspace[];
-  listWorkspacesWithScript(scriptName: string): Workspace[];
-  listScriptsWithWorkspaces(): Record<string, ScriptMetadata>;
-  findWorkspaceByName(workspaceName: string): Workspace | null;
-  findWorkspaceByAlias(alias: string): Workspace | null;
-  findWorkspaceByNameOrAlias(nameOrAlias: string): Workspace | null;
-  findWorkspacesByPattern(workspaceName: string): Workspace[];
-  createScriptCommand(
-    options: CreateProjectScriptCommandOptions,
-  ): CreateProjectScriptCommandResult;
-}
-
-export interface CreateProjectOptions {
-  rootDir: string;
-  workspaceAliases?: Record<string, string>;
-}
-
-class _Project implements Project {
-  public readonly rootDir: string;
-  public readonly workspaceAliases?: Record<string, string>;
-  public readonly workspaces: Workspace[];
-  public readonly name: string;
-  constructor(private options: CreateProjectOptions) {
-    this.rootDir = options.rootDir;
-    this.workspaceAliases = options.workspaceAliases;
-
-    const { name, workspaces } = findWorkspacesFromPackage({
-      rootDir: options.rootDir,
-      workspaceAliases: options.workspaceAliases,
-    });
-
-    this.name = name;
-    this.workspaces = workspaces;
-  }
-
-  listWorkspacesWithScript(scriptName: string): Workspace[] {
-    return this.workspaces.filter(
-      (workspace) => workspace.packageJson.scripts?.[scriptName],
-    );
-  }
-
-  listScriptsWithWorkspaces(): Record<string, ScriptMetadata> {
-    const scripts = new Set<string>();
-    this.workspaces.forEach((workspace) => {
-      Object.keys(workspace.packageJson.scripts ?? {}).forEach((script) =>
-        scripts.add(script),
-      );
-    });
-    return Array.from(scripts)
-      .sort((a, b) => a.localeCompare(b))
-      .map((name) => ({
-        name,
-        workspaces: this.listWorkspacesWithScript(name),
-      }))
-      .reduce(
-        (acc, { name, workspaces }) => ({
-          ...acc,
-          [name]: { name, workspaces },
-        }),
-        {} as Record<string, ScriptMetadata>,
-      );
-  }
-
-  findWorkspaceByName(workspaceName: string): Workspace | null {
-    return (
-      this.workspaces.find((workspace) => workspace.name === workspaceName) ??
-      null
-    );
-  }
-
-  findWorkspaceByAlias(alias: string): Workspace | null {
-    return (
-      this.workspaces.find((workspace) => workspace.aliases.includes(alias)) ??
-      null
-    );
-  }
-
-  findWorkspaceByNameOrAlias(nameOrAlias: string): Workspace | null {
-    return (
-      this.findWorkspaceByName(nameOrAlias) ||
-      this.findWorkspaceByAlias(nameOrAlias)
-    );
-  }
-
-  /** Accepts wildcard for finding a list of workspaces */
-  findWorkspacesByPattern(workspacePattern: string): Workspace[] {
-    if (!workspacePattern) return [];
-    const regex = createWildcardRegex(workspacePattern);
-    return this.workspaces.filter((workspace) => regex.test(workspace.name));
-  }
-
-  createScriptCommand(
-    options: CreateProjectScriptCommandOptions,
-  ): CreateProjectScriptCommandResult {
-    const workspace = this.findWorkspaceByNameOrAlias(options.workspaceName);
-
-    if (!workspace) {
-      throw new ERRORS.ProjectWorkspaceNotFound(
-        `Workspace not found: ${JSON.stringify(options.workspaceName)}`,
-      );
-    }
-    if (!workspace.packageJson.scripts?.[options.scriptName]) {
-      throw new ERRORS.WorkspaceScriptDoesNotExist(
-        `Script not found in workspace ${JSON.stringify(
-          workspace.name,
-        )}: ${JSON.stringify(options.scriptName)} (available: ${
-          Object.keys(workspace.packageJson.scripts).join(", ") || "none"
-        }`,
-      );
-    }
-    return {
-      workspace,
-      scriptName: options.scriptName,
-      command: createScriptCommand({
-        ...options,
-        workspace,
-        rootDir: path.resolve(this.rootDir),
-      }),
-    };
-  }
-}
-
-export const createProject = (options: CreateProjectOptions): Project =>
-  new _Project(options);

package/src/project/scriptCommand.ts

@@ -1,40 +0,0 @@
-import path from "path";
-import type { Workspace } from "../workspaces";
-
-export const SCRIPT_COMMAND_METHODS = ["cd", "filter"] as const;
-
-export type ScriptCommandMethod = (typeof SCRIPT_COMMAND_METHODS)[number];
-
-export interface CreateScriptCommandOptions {
-  method: ScriptCommandMethod;
-  scriptName: string;
-  args: string;
-  workspace: Workspace;
-  rootDir: string;
-}
-
-const spaceArgs = (args: string) => (args ? ` ${args.trim()}` : "");
-
-export interface ScriptCommand {
-  command: string;
-  cwd: string;
-}
-
-const METHODS: Record<
-  ScriptCommandMethod,
-  (options: CreateScriptCommandOptions) => ScriptCommand
-> = {
-  cd: ({ scriptName, workspace, rootDir, args }) => ({
-    cwd: path.resolve(rootDir, workspace.path),
-    command: `bun --silent run ${scriptName}${spaceArgs(args)}`,
-  }),
-  filter: ({ scriptName, workspace, args, rootDir }) => ({
-    cwd: rootDir,
-    command: `bun --silent run --filter=${JSON.stringify(
-      workspace.name,
-    )} ${scriptName}${spaceArgs(args)}`,
-  }),
-};
-
-export const createScriptCommand = (options: CreateScriptCommandOptions) =>
-  METHODS[options.method](options);

package/src/workspaces/errors.ts

@@ -1,14 +0,0 @@
-import { defineErrors } from "../internal/error";
-
-export const ERRORS = defineErrors(
-  "PackageNotFound",
-  "InvalidPackageJson",
-  "DuplicateWorkspaceName",
-  "InvalidWorkspaceName",
-  "NoWorkspaceName",
-  "InvalidScripts",
-  "InvalidWorkspaces",
-  "InvalidWorkspacePattern",
-  "AliasConflict",
-  "AliasedWorkspaceNotFound",
-);

package/src/workspaces/findWorkspaces.ts

@@ -1,137 +0,0 @@
-import fs from "fs";
-import path from "path";
-import type { ProjectConfig } from "../config";
-import { logger } from "../internal/logger";
-import { ERRORS } from "./errors";
-import {
-  resolvePackageJsonContent,
-  resolvePackageJsonPath,
-  scanWorkspaceGlob,
-} from "./packageJson";
-import type { Workspace } from "./workspace";
-
-export interface FindWorkspacesOptions {
-  rootDir: string;
-  workspaceGlobs: string[];
-  workspaceAliases?: ProjectConfig["workspaceAliases"];
-}
-
-const validatePattern = (pattern: string) => {
-  if (pattern.startsWith("!")) {
-    logger.warn(
-      `Negation patterns are not supported by Bun workspaces: ${JSON.stringify(
-        pattern,
-      )}`,
-    );
-    return false;
-  }
-  return true;
-};
-
-const validateWorkspace = (workspace: Workspace, workspaces: Workspace[]) => {
-  if (workspaces.find((ws) => ws.path === workspace.path)) {
-    return false;
-  }
-
-  if (workspaces.find((ws) => ws.name === workspace.name)) {
-    throw new ERRORS.DuplicateWorkspaceName(
-      `Duplicate workspace name found: ${JSON.stringify(workspace.name)}`,
-    );
-  }
-
-  return true;
-};
-
-export const findWorkspaces = ({
-  rootDir,
-  workspaceGlobs,
-  workspaceAliases,
-}: FindWorkspacesOptions) => {
-  rootDir = path.resolve(rootDir);
-
-  const workspaces: Workspace[] = [];
-
-  for (const pattern of workspaceGlobs) {
-    if (!validatePattern(pattern)) continue;
-
-    for (const item of scanWorkspaceGlob(pattern, rootDir)) {
-      const packageJsonPath = resolvePackageJsonPath(item);
-      if (packageJsonPath) {
-        const packageJsonContent = resolvePackageJsonContent(
-          packageJsonPath,
-          rootDir,
-          ["name", "scripts"],
-        );
-
-        const workspace: Workspace = {
-          name: packageJsonContent.name ?? "",
-          matchPattern: pattern,
-          path: path.relative(rootDir, path.dirname(packageJsonPath)),
-          packageJson: packageJsonContent,
-          aliases: Object.entries(workspaceAliases ?? {})
-            .filter(([_, value]) => value === packageJsonContent.name)
-            .map(([key]) => key),
-        };
-
-        if (validateWorkspace(workspace, workspaces)) {
-          workspaces.push(workspace);
-        }
-      }
-    }
-  }
-
-  workspaces.sort(
-    (a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path),
-  );
-
-  return { workspaces };
-};
-
-export const validateWorkspaceAliases = (
-  workspaces: Workspace[],
-  workspaceAliases: ProjectConfig["workspaceAliases"],
-) => {
-  for (const [alias, name] of Object.entries(workspaceAliases ?? {})) {
-    if (workspaces.find((ws) => ws.name === alias)) {
-      throw new ERRORS.AliasConflict(
-        `Alias ${JSON.stringify(alias)} conflicts with workspace name ${JSON.stringify(name)}`,
-      );
-    }
-    if (!workspaces.find((ws) => ws.name === name)) {
-      throw new ERRORS.AliasedWorkspaceNotFound(
-        `Workspace ${JSON.stringify(name)} was aliased by ${JSON.stringify(
-          alias,
-        )} but was not found`,
-      );
-    }
-  }
-};
-
-export const findWorkspacesFromPackage = ({
-  rootDir,
-  workspaceAliases,
-}: ProjectConfig & { rootDir: string }) => {
-  const packageJsonPath = path.join(rootDir, "package.json");
-  if (!fs.existsSync(packageJsonPath)) {
-    throw new ERRORS.PackageNotFound(
-      `No package.json found at ${packageJsonPath}`,
-    );
-  }
-
-  const packageJson = resolvePackageJsonContent(packageJsonPath, rootDir, [
-    "workspaces",
-  ]);
-
-  const result = findWorkspaces({
-    rootDir,
-    workspaceGlobs: packageJson.workspaces ?? [],
-    workspaceAliases,
-  });
-
-  validateWorkspaceAliases(result.workspaces, workspaceAliases);
-
-  return {
-    ...result,
-    name: packageJson.name ?? "",
-  };
-};

package/src/workspaces/index.ts

@@ -1,7 +0,0 @@
-export {
-  findWorkspaces,
-  findWorkspacesFromPackage,
-  type FindWorkspacesOptions,
-} from "./findWorkspaces";
-export { type Workspace } from "./workspace";
-export type { ResolvedPackageJsonContent } from "./packageJson";