bun-workspaces 0.2.0 → 1.0.0-alpha

package/src/internal/logger.ts

@@ -1,17 +1,145 @@
-import createLogger from "pino";
+import { IS_PRODUCTION, IS_TEST } from "./env";
 
-export const logger = createLogger({
-  msgPrefix: "[bun-workspaces] ",
-  level:
-    process.env.NODE_ENV === "test"
+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"
-      : process.env.NODE_ENV === "development"
-        ? "debug"
-        : "info",
-  transport: {
-    target: "pino-pretty",
-    options: {
-      color: true,
-    },
-  },
-});
+      : "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/project/project.ts

@@ -33,6 +33,8 @@ export interface Project {
   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,
@@ -41,17 +43,23 @@ export interface Project {
 
 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;
   }
@@ -70,6 +78,7 @@ class _Project implements Project {
       );
     });
     return Array.from(scripts)
+      .sort((a, b) => a.localeCompare(b))
       .map((name) => ({
         name,
         workspaces: this.listWorkspacesWithScript(name),
@@ -90,6 +99,20 @@ class _Project implements Project {
     );
   }
 
+  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 [];
@@ -100,7 +123,8 @@ class _Project implements Project {
   createScriptCommand(
     options: CreateProjectScriptCommandOptions,
   ): CreateProjectScriptCommandResult {
-    const workspace = this.findWorkspaceByName(options.workspaceName);
+    const workspace = this.findWorkspaceByNameOrAlias(options.workspaceName);
+
     if (!workspace) {
       throw new ERRORS.ProjectWorkspaceNotFound(
         `Workspace not found: ${JSON.stringify(options.workspaceName)}`,

package/src/workspaces/errors.ts

@@ -4,8 +4,11 @@ export const ERRORS = defineErrors(
   "PackageNotFound",
   "InvalidPackageJson",
   "DuplicateWorkspaceName",
+  "InvalidWorkspaceName",
   "NoWorkspaceName",
   "InvalidScripts",
   "InvalidWorkspaces",
   "InvalidWorkspacePattern",
+  "AliasConflict",
+  "AliasedWorkspaceNotFound",
 );

package/src/workspaces/findWorkspaces.ts

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { Glob } from "bun";
+import type { ProjectConfig } from "../config";
 import { logger } from "../internal/logger";
 import { ERRORS } from "./errors";
 import {
@@ -13,6 +13,7 @@ import type { Workspace } from "./workspace";
 export interface FindWorkspacesOptions {
   rootDir: string;
   workspaceGlobs: string[];
+  workspaceAliases?: ProjectConfig["workspaceAliases"];
 }
 
 const validatePattern = (pattern: string) => {
@@ -44,6 +45,7 @@ const validateWorkspace = (workspace: Workspace, workspaces: Workspace[]) => {
 export const findWorkspaces = ({
   rootDir,
   workspaceGlobs,
+  workspaceAliases,
 }: FindWorkspacesOptions) => {
   rootDir = path.resolve(rootDir);
 
@@ -52,8 +54,7 @@ export const findWorkspaces = ({
   for (const pattern of workspaceGlobs) {
     if (!validatePattern(pattern)) continue;
 
-    const glob = new Glob(pattern);
-    for (const item of scanWorkspaceGlob(glob, rootDir)) {
+    for (const item of scanWorkspaceGlob(pattern, rootDir)) {
       const packageJsonPath = resolvePackageJsonPath(item);
       if (packageJsonPath) {
         const packageJsonContent = resolvePackageJsonContent(
@@ -67,6 +68,9 @@ export const findWorkspaces = ({
           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)) {
@@ -83,13 +87,30 @@ export const findWorkspaces = ({
   return { workspaces };
 };
 
-export interface FindWorkspacesFromPackageOptions {
-  rootDir: string;
-}
+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,
-}: FindWorkspacesFromPackageOptions) => {
+  workspaceAliases,
+}: ProjectConfig & { rootDir: string }) => {
   const packageJsonPath = path.join(rootDir, "package.json");
   if (!fs.existsSync(packageJsonPath)) {
     throw new ERRORS.PackageNotFound(
@@ -101,11 +122,16 @@ export const findWorkspacesFromPackage = ({
     "workspaces",
   ]);
 
+  const result = findWorkspaces({
+    rootDir,
+    workspaceGlobs: packageJson.workspaces ?? [],
+    workspaceAliases,
+  });
+
+  validateWorkspaceAliases(result.workspaces, workspaceAliases);
+
   return {
-    ...findWorkspaces({
-      rootDir,
-      workspaceGlobs: packageJson.workspaces ?? [],
-    }),
+    ...result,
     name: packageJson.name ?? "",
   };
 };

package/src/workspaces/index.ts

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

package/src/workspaces/packageJson.ts

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { Glob } from "bun";
+import { Glob } from "glob";
 import { logger } from "../internal/logger";
 import { ERRORS } from "./errors";
 
@@ -22,12 +22,8 @@ export type ResolvedPackageJsonContent = {
 
 type UnknownPackageJson = Record<string, unknown>;
 
-export const scanWorkspaceGlob = (glob: Glob, rootDir: string) =>
-  glob.scanSync({
-    cwd: rootDir,
-    onlyFiles: false,
-    absolute: true,
-  });
+export const scanWorkspaceGlob = (pattern: string, rootDir: string) =>
+  new Glob(pattern, { absolute: true, cwd: rootDir }).iterateSync();
 
 const validateJsonRoot = (json: UnknownPackageJson) => {
   if (!json || typeof json !== "object" || Array.isArray(json)) {
@@ -46,6 +42,18 @@ const validateName = (json: UnknownPackageJson) => {
     );
   }
 
+  if (!json.name.trim()) {
+    throw new ERRORS.NoWorkspaceName(
+      `Expected package.json to have a non-empty "name" field`,
+    );
+  }
+
+  if (json.name.includes("*")) {
+    throw new ERRORS.InvalidWorkspaceName(
+      `Package name cannot contain the character '*' (workspace: "${json.name}")`,
+    );
+  }
+
   return json.name;
 };
 
@@ -133,7 +141,7 @@ export const resolvePackageJsonContent = (
   try {
     json = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
   } catch (error) {
-    logger.error(error);
+    logger.error(error as Error);
     throw new ERRORS.InvalidPackageJson(
       `Failed to read and parse package.json at ${packageJsonPath}: ${
         (error as Error).message

package/src/workspaces/workspace.ts

@@ -9,4 +9,6 @@ export interface Workspace {
   matchPattern: string;
   /** The contents of the workspace's package.json, with `"workspaces"` and `"scripts"` resolved */
   packageJson: ResolvedPackageJsonContent;
+  /** Aliases assigned to the workspace via the `"workspaceAliases"` field in the config */
+  aliases: string[];
 }

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     // Enable latest features
-    "lib": ["ESNext", "DOM"],
+    "lib": ["ESNext", "DOM", "DOM.AsyncIterable", "DOM.Iterable"],
     "target": "ESNext",
     "module": "ESNext",
     "moduleDetection": "force",

package/.vscode/extensions.json

@@ -1,12 +0,0 @@
-{
-  "recommendations": [
-    "esbenp.prettier-vscode",
-    "oven.bun-vscode",
-    "streetsidesoftware.code-spell-checker",
-    "jasonnutter.vscode-codeowners",
-    "EditorConfig.EditorConfig",
-    "dbaeumer.vscode-eslint",
-    "github.vscode-github-actions",
-    "aaron-bond.better-comments"
-  ]
-}

package/.vscode/settings.json

@@ -1,23 +0,0 @@
-{
-  "editor.codeActionsOnSave": {
-    "source.fixAll.eslint": "explicit"
-  },
-  "eslint.codeActionsOnSave.rules": ["import/order"],
-  "eslint.validate": ["javascript", "typescript"],
-  "[typescript]": {
-    "editor.formatOnSave": true,
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[javascript]": {
-    "editor.formatOnSave": true,
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[json]": {
-    "editor.formatOnSave": true,
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[jsonc]": {
-    "editor.formatOnSave": true,
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  }
-}

package/eslint.config.mjs

@@ -1,45 +0,0 @@
-import js from "@eslint/js";
-import importPlugin from "eslint-plugin-import";
-import typescriptEslint from "typescript-eslint";
-
-export default [
-  ...typescriptEslint.config(
-    js.configs.recommended,
-    typescriptEslint.configs.recommended,
-  ),
-  {
-    plugins: {
-      import: importPlugin,
-    },
-    rules: {
-      "@typescript-eslint/no-empty-interface": "off",
-      "@typescript-eslint/no-empty-function": "off",
-      "no-empty": "warn",
-      "@typescript-eslint/no-extra-semi": "off",
-      "@typescript-eslint/no-explicit-any": "off",
-
-      "@typescript-eslint/no-unused-vars": [
-        "warn",
-        {
-          varsIgnorePattern: "^_",
-          argsIgnorePattern: "^_",
-          destructuredArrayIgnorePattern: "^_",
-          caughtErrorsIgnorePattern: "^_",
-        },
-      ],
-
-      eqeqeq: "error",
-      "prefer-const": "error",
-
-      "import/order": [
-        "warn",
-        {
-          alphabetize: {
-            order: "asc",
-            caseInsensitive: true,
-          },
-        },
-      ],
-    },
-  },
-];

package/src/cli/output.ts

@@ -1,6 +0,0 @@
-import { IS_TEST } from "../internal/env";
-
-export const OUTPUT_CONFIG = {
-  writeOut: (s: string) => !IS_TEST && process.stdout.write(s),
-  writeErr: (s: string) => !IS_TEST && process.stderr.write(s),
-};