bun-workspaces 1.0.0-alpha.4 → 1.0.0-alpha.7

package/src/internal/regex.d.ts

@@ -0,0 +1,2 @@
+export declare const createRawPattern: (pattern: string) => string;
+export declare const createWildcardRegex: (pattern: string) => RegExp;

package/src/internal/regex.mjs

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

package/src/project/errors.d.ts

@@ -0,0 +1 @@
+export declare const ERRORS: import("../internal/error").DefinedErrors<"ProjectWorkspaceNotFound" | "WorkspaceScriptDoesNotExist">;

package/src/project/errors.mjs

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

package/src/project/index.d.ts

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

package/src/project/index.mjs

@@ -0,0 +1,2 @@
+import { createProject } from "./project.mjs";
+export { createProject };

package/src/project/project.d.ts

@@ -0,0 +1,31 @@
+import { type Workspace } from "../workspaces";
+import { 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>;
+}
+export declare const createProject: (options: CreateProjectOptions) => Project;

package/src/project/project.mjs

@@ -0,0 +1,72 @@
+import path from "path";
+import { createWildcardRegex } from "../internal/regex.mjs";
+import { findWorkspacesFromPackage } from "../workspaces/index.mjs";
+import { ERRORS } from "./errors.mjs";
+import { createScriptCommand } from "./scriptCommand.mjs";
+class _Project {
+    options;
+    rootDir;
+    workspaceAliases;
+    workspaces;
+    name;
+    constructor(options){
+        this.options = options;
+        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) {
+        return this.workspaces.filter((workspace)=>workspace.packageJson.scripts?.[scriptName]);
+    }
+    listScriptsWithWorkspaces() {
+        const scripts = new Set();
+        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
+                }
+            }), {});
+    }
+    findWorkspaceByName(workspaceName) {
+        return this.workspaces.find((workspace)=>workspace.name === workspaceName) ?? null;
+    }
+    findWorkspaceByAlias(alias) {
+        return this.workspaces.find((workspace)=>workspace.aliases.includes(alias)) ?? null;
+    }
+    findWorkspaceByNameOrAlias(nameOrAlias) {
+        return this.findWorkspaceByName(nameOrAlias) || this.findWorkspaceByAlias(nameOrAlias);
+    }
+    findWorkspacesByPattern(workspacePattern) {
+        if (!workspacePattern) return [];
+        const regex = createWildcardRegex(workspacePattern);
+        return this.workspaces.filter((workspace)=>regex.test(workspace.name));
+    }
+    createScriptCommand(options) {
+        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)
+            })
+        };
+    }
+}
+const createProject = (options)=>new _Project(options);
+export { createProject };

package/src/project/scriptCommand.d.ts

@@ -0,0 +1,15 @@
+import type { Workspace } from "../workspaces";
+export declare const SCRIPT_COMMAND_METHODS: readonly ["cd", "filter"];
+export type ScriptCommandMethod = (typeof SCRIPT_COMMAND_METHODS)[number];
+export interface CreateScriptCommandOptions {
+    method: ScriptCommandMethod;
+    scriptName: string;
+    args: string;
+    workspace: Workspace;
+    rootDir: string;
+}
+export interface ScriptCommand {
+    command: string;
+    cwd: string;
+}
+export declare const createScriptCommand: (options: CreateScriptCommandOptions) => ScriptCommand;

package/src/project/scriptCommand.mjs

@@ -0,0 +1,18 @@
+import path from "path";
+const SCRIPT_COMMAND_METHODS = [
+    "cd",
+    "filter"
+];
+const spaceArgs = (args)=>args ? ` ${args.trim()}` : "";
+const METHODS = {
+    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)}`
+        })
+};
+const createScriptCommand = (options)=>METHODS[options.method](options);
+export { SCRIPT_COMMAND_METHODS, createScriptCommand };

package/src/workspaces/errors.d.ts

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

package/src/workspaces/errors.mjs

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

package/src/workspaces/findWorkspaces.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectConfig } from "../config";
+import type { Workspace } from "./workspace";
+export interface FindWorkspacesOptions {
+    rootDir: string;
+    workspaceGlobs: string[];
+    workspaceAliases?: ProjectConfig["workspaceAliases"];
+}
+export declare const findWorkspaces: ({ rootDir, workspaceGlobs, workspaceAliases, }: FindWorkspacesOptions) => {
+    workspaces: Workspace[];
+};
+export declare const validateWorkspaceAliases: (workspaces: Workspace[], workspaceAliases: Record<string, string> | undefined) => void;
+export declare const findWorkspacesFromPackage: ({ rootDir, workspaceAliases, }: ProjectConfig & {
+    rootDir: string;
+}) => {
+    workspaces: Workspace[];
+    name: string;
+};

package/src/workspaces/findWorkspaces.mjs

@@ -0,0 +1,66 @@
+import fs from "fs";
+import path from "path";
+import { logger } from "../internal/logger.mjs";
+import { ERRORS } from "./errors.mjs";
+import { resolvePackageJsonContent, resolvePackageJsonPath, scanWorkspaceGlob } from "./packageJson.mjs";
+const validatePattern = (pattern)=>{
+    if (pattern.startsWith("!")) {
+        logger.warn(`Negation patterns are not supported by Bun workspaces: ${JSON.stringify(pattern)}`);
+        return false;
+    }
+    return true;
+};
+const validateWorkspace = (workspace, workspaces)=>{
+    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;
+};
+const findWorkspaces = ({ rootDir, workspaceGlobs, workspaceAliases })=>{
+    rootDir = path.resolve(rootDir);
+    const workspaces = [];
+    for (const pattern of workspaceGlobs)if (validatePattern(pattern)) for (const item of scanWorkspaceGlob(pattern, rootDir)){
+        const packageJsonPath = resolvePackageJsonPath(item);
+        if (packageJsonPath) {
+            const packageJsonContent = resolvePackageJsonContent(packageJsonPath, rootDir, [
+                "name",
+                "scripts"
+            ]);
+            const 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
+    };
+};
+const validateWorkspaceAliases = (workspaces, 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`);
+    }
+};
+const findWorkspacesFromPackage = ({ rootDir, workspaceAliases })=>{
+    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 ?? ""
+    };
+};
+export { findWorkspaces, findWorkspacesFromPackage, validateWorkspaceAliases };

package/src/workspaces/index.d.ts

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

package/src/workspaces/index.mjs

@@ -0,0 +1,2 @@
+import { findWorkspaces, findWorkspacesFromPackage } from "./findWorkspaces.mjs";
+export { findWorkspaces, findWorkspacesFromPackage };

package/src/workspaces/packageJson.d.ts

@@ -0,0 +1,8 @@
+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: (pattern: string, rootDir: string) => Generator<string, void, void>;
+export declare const resolvePackageJsonContent: (packageJsonPath: string, rootDir: string, validations: ("name" | "scripts" | "workspaces")[]) => ResolvedPackageJsonContent;

package/src/workspaces/packageJson.mjs

@@ -0,0 +1,65 @@
+import fs from "fs";
+import path from "path";
+import { Glob } from "glob";
+import { logger } from "../internal/logger.mjs";
+import { ERRORS } from "./errors.mjs";
+const resolvePackageJsonPath = (directoryItem)=>{
+    if ("package.json" === path.basename(directoryItem)) return directoryItem;
+    if (fs.existsSync(path.join(directoryItem, "package.json"))) return path.join(directoryItem, "package.json");
+    return "";
+};
+const scanWorkspaceGlob = (pattern, rootDir)=>new Glob(pattern, {
+        absolute: true,
+        cwd: rootDir
+    }).iterateSync();
+const validateJsonRoot = (json)=>{
+    if (!json || "object" != typeof json || Array.isArray(json)) throw new ERRORS.InvalidPackageJson(`Expected package.json to be an object, got ${typeof json}`);
+};
+const validateName = (json)=>{
+    if ("string" != typeof json.name) throw new ERRORS.NoWorkspaceName(`Expected package.json to have a string "name" field${void 0 !== json.name ? ` (Received ${json.name})` : ""}`);
+    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;
+};
+const validateWorkspacePattern = (workspacePattern, rootDir)=>{
+    if ("string" != typeof workspacePattern) throw new ERRORS.InvalidWorkspacePattern(`Expected workspace pattern to be a string, got ${typeof workspacePattern}`);
+    if (!workspacePattern.trim()) return false;
+    const absolutePattern = path.resolve(rootDir, workspacePattern);
+    if (!absolutePattern.startsWith(rootDir)) throw new ERRORS.InvalidWorkspacePattern(`Cannot resolve workspace pattern outside of root directory ${rootDir}: ${absolutePattern}`);
+    return true;
+};
+const validateWorkspacePatterns = (json, rootDir)=>{
+    const workspaces = [];
+    if (json.workspaces) {
+        if (!Array.isArray(json.workspaces)) throw new ERRORS.InvalidWorkspaces('Expected package.json to have an array "workspaces" field');
+        for (const workspacePattern of json.workspaces)if (validateWorkspacePattern(workspacePattern, rootDir)) workspaces.push(workspacePattern);
+    }
+    return workspaces;
+};
+const validateScripts = (json)=>{
+    if (json.scripts && ("object" != typeof json.scripts || Array.isArray(json.scripts))) throw new ERRORS.InvalidScripts('Expected package.json to have an object "scripts" field');
+    if (json.scripts) {
+        for (const value of Object.values(json.scripts))if ("string" != typeof value) throw new ERRORS.InvalidScripts(`Expected workspace "${json.name}" script "${json.scripts}" to be a string, got ${typeof value}`);
+    }
+    return {
+        ...json.scripts
+    };
+};
+const resolvePackageJsonContent = (packageJsonPath, rootDir, validations)=>{
+    rootDir = path.resolve(rootDir);
+    let json = {};
+    try {
+        json = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    } catch (error) {
+        logger.error(error);
+        throw new 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, rootDir) : json?.workspaces ?? [],
+        scripts: validations.includes("scripts") ? validateScripts(json) : json.scripts ?? {}
+    };
+};
+export { resolvePackageJsonContent, resolvePackageJsonPath, scanWorkspaceGlob };

package/src/workspaces/workspace.d.ts

@@ -0,0 +1,13 @@
+import type { ResolvedPackageJsonContent } from "./packageJson";
+export interface 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;
+    /** Aliases assigned to the workspace via the `"workspaceAliases"` field in the config */
+    aliases: string[];
+}

package/LICENSE.md

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Scott Morse
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.