feat(cli): --filter flag

CMakeLists.txt

@@ -5,6 +5,8 @@ cmake_policy(SET CMP0067 NEW)
 set(Bun_VERSION "1.0.23")
 set(WEBKIT_TAG b4de09f41b83e9e5c0e43ef414f1aee5968b6f7c)
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 set(BUN_WORKDIR "${CMAKE_CURRENT_BINARY_DIR}")
 message(STATUS "Configuring Bun ${Bun_VERSION} in ${BUN_WORKDIR}")
 

src/api/schema.zig

@@ -1689,8 +1689,8 @@ pub const Api = struct {
  /// origin
  origin: ?[]const u8 = null,
 
- /// absolute_working_dir
- absolute_working_dir: ?[]const u8 = null,
+ /// cwd_override
+ cwd_override: ?[]const u8 = null,
 
  /// define
  define: ?StringMap = null,
@@ -1774,7 +1774,7 @@ pub const Api = struct {
  this.origin = try reader.readValue([]const u8);
  },
  5 => {
- this.absolute_working_dir = try reader.readValue([]const u8);
+ this.cwd_override = try reader.readValue([]const u8);
  },
  6 => {
  this.define = try reader.readValue(StringMap);
@@ -1861,9 +1861,9 @@ pub const Api = struct {
  try writer.writeFieldID(4);
  try writer.writeValue(@TypeOf(origin), origin);
  }
- if (this.absolute_working_dir) |absolute_working_dir| {
+ if (this.cwd_override) |cwd_override| {
  try writer.writeFieldID(5);
- try writer.writeValue(@TypeOf(absolute_working_dir), absolute_working_dir);
+ try writer.writeValue(@TypeOf(cwd_override), cwd_override);
  }
  if (this.define) |define| {
  try writer.writeFieldID(6);

src/bundler.zig

@@ -388,7 +388,7 @@ pub const Bundler = struct {
  js_ast.Expr.Data.Store.create(allocator);
  js_ast.Stmt.Data.Store.create(allocator);
  const fs = try Fs.FileSystem.init(
- opts.absolute_working_dir,
+ opts.cwd_override,
  );
  const bundle_options = try options.BundleOptions.fromApi(
  allocator,

src/bundler/bundle_v2.zig

@@ -1605,7 +1605,7 @@ pub const BundleV2 = struct {
  .define = if (config.define.count() > 0) config.define.toAPI() else null,
  .entry_points = config.entry_points.keys(),
  .target = config.target.toAPI(),
- .absolute_working_dir = if (config.dir.list.items.len > 0) config.dir.toOwnedSliceLeaky() else null,
+ .cwd_override = if (config.dir.list.items.len > 0) config.dir.toOwnedSliceLeaky() else null,
  .inject = &.{},
  .external = config.external.keys(),
  .main_fields = &.{},

src/cli.zig

@@ -20,6 +20,9 @@ const js_printer = bun.js_printer;
 const js_ast = bun.JSAst;
 const linker = @import("linker.zig");
 const RegularExpression = bun.RegularExpression;
+const Glob = @import("glob.zig");
+
+const Package = @import("install/lockfile.zig").Package;
 
 const sync = @import("./sync.zig");
 const Api = @import("api/schema.zig").Api;
@@ -148,6 +151,9 @@ pub const Arguments = struct {
  const base_params_ = [_]ParamType{
  clap.parseParam("--env-file <STR>... Load environment variables from the specified file(s)") catch unreachable,
  clap.parseParam("--cwd <STR> Absolute path to resolve files & entry points from. This just changes the process' cwd.") catch unreachable,
+ // clap.parseParam("-w, --workspace <STR> Perform the command on the specified workspace member package") catch unreachable,
+ clap.parseParam("--filter <STR>... Perform the command on all workspace member packages that match the pattern") catch unreachable,
+ // clap.parseParam("--fail-if-no-match Fail if no packages match the filter") catch unreachable,
  clap.parseParam("-c, --config <PATH>? Specify path to Bun config file. Default <d>$cwd<r>/bunfig.toml") catch unreachable,
  clap.parseParam("-h, --help Display this menu and exit") catch unreachable,
  clap.parseParam("<POS>...") catch unreachable,
@@ -336,16 +342,17 @@ pub const Arguments = struct {
  config_buf[config_path_.len] = 0;
  config_path = config_buf[0..config_path_.len :0];
  } else {
- if (ctx.args.absolute_working_dir == null) {
- var secondbuf: [bun.MAX_PATH_BYTES]u8 = undefined;
- const cwd = bun.getcwd(&secondbuf) catch return;
-
- ctx.args.absolute_working_dir = try allocator.dupe(u8, cwd);
+ var cwd_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
+ var cwd: []const u8 = undefined;
+ if (ctx.args.cwd_override) |cwd_val| {
+ cwd = cwd_val;
+ } else {
+ cwd = try bun.getcwd(&cwd_buf);
  }
 
- var parts = [_]string{ ctx.args.absolute_working_dir.?, config_path_ };
+ var parts = [_]string{ cwd, config_path_ };
  config_path_ = resolve_path.joinAbsStringBuf(
- ctx.args.absolute_working_dir.?,
+ cwd,
  &config_buf,
  &parts,
  .auto,
@@ -402,20 +409,26 @@ pub const Arguments = struct {
  }
  }
 
- var cwd: []u8 = undefined;
+ var cwd_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
+ var cwd: []const u8 = undefined;
  if (args.option("--cwd")) |cwd_| {
- cwd = brk: {
- var outbuf: [bun.MAX_PATH_BYTES]u8 = undefined;
- const out = std.os.realpath(cwd_, &outbuf) catch |err| {
- Output.prettyErrorln("error resolving --cwd: {s}", .{@errorName(err)});
- Global.exit(1);
- };
- break :brk try allocator.dupe(u8, out);
+ var outbuf: [bun.MAX_PATH_BYTES]u8 = undefined;
+ const out = std.os.realpath(cwd_, &outbuf) catch |err| {
+ Output.prettyErrorln("error resolving --cwd: {s}", .{@errorName(err)});
+ Global.exit(1);
+ };
+ std.os.chdir(out) catch |err| {
+ Output.prettyErrorln("error setting --cwd: {s}", .{@errorName(err)});
+ Global.exit(1);
  };
+ cwd = try allocator.dupe(u8, out);
+ ctx.args.cwd_override = cwd;
  } else {
- cwd = try bun.getcwdAlloc(allocator);
+ cwd = try bun.getcwd(&cwd_buf);
  }
 
+ ctx.filters = args.options("--filter");
+
  if (cmd == .TestCommand) {
  if (args.option("--timeout")) |timeout_ms| {
  if (timeout_ms.len > 0) {
@@ -472,7 +485,6 @@ pub const Arguments = struct {
  ctx.test_options.only = args.flag("--only");
  }
 
- ctx.args.absolute_working_dir = cwd;
  ctx.positionals = args.positionals();
 
  if (comptime Command.Tag.loads_config.get(cmd)) {
@@ -1087,6 +1099,8 @@ pub const Command = struct {
  bundler_options: BundlerOptions = BundlerOptions{},
  runtime_options: RuntimeOptions = RuntimeOptions{},
 
+ filters: []const []const u8 = &[_][]const u8{},
+
  preloads: []const string = &[_]string{},
  has_loaded_global_config: bool = false,
 
@@ -1608,11 +1622,7 @@ pub const Command = struct {
  const ctx = try Command.Context.create(allocator, log, .RunCommand);
 
  if (ctx.positionals.len > 0) {
- if (try RunCommand.exec(ctx, false, true)) {
- return;
- }
-
- Global.exit(1);
+ try RunCommand.execAll(ctx, false);
  }
  },
  .RunAsNodeCommand => {
@@ -1721,6 +1731,9 @@ pub const Command = struct {
  }
 
  if (ctx.positionals.len > 0 and extension.len == 0) {
+ if (ctx.filters.len > 0) {
+ Output.prettyln("<r><yellow>warn<r>: Filters are ignored for auto command", .{});
+ }
  if (try RunCommand.exec(ctx, true, false)) {
  return;
  }

src/cli/filter_arg.zig

@@ -0,0 +1,183 @@
+const std = @import("std");
+const root = @import("root");
+const bun = root.bun;
+const string = bun.string;
+const Output = bun.Output;
+const Global = bun.Global;
+const strings = bun.strings;
+const json_parser = bun.JSON;
+const Glob = @import("../glob.zig");
+
+const Package = @import("../install/lockfile.zig").Package;
+
+fn findWorkspaceMembers(allocator: std.mem.Allocator, log: *bun.logger.Log, workspace_map: *Package.WorkspaceMap, workdir_: []const u8) !void {
+ bun.JSAst.Expr.Data.Store.create(bun.default_allocator);
+ bun.JSAst.Stmt.Data.Store.create(bun.default_allocator);
+
+ defer {
+ bun.JSAst.Expr.Data.Store.reset();
+ bun.JSAst.Stmt.Data.Store.reset();
+ }
+
+ var workdir = workdir_;
+
+ while (true) : (workdir = std.fs.path.dirname(workdir) orelse break) {
+ const parent_trimmed = strings.withoutTrailingSlash(workdir);
+ var buf2: [bun.MAX_PATH_BYTES + 1]u8 = undefined;
+ @memcpy(buf2[0..parent_trimmed.len], parent_trimmed);
+ buf2[parent_trimmed.len..buf2.len][0.."/package.json".len].* = "/package.json".*;
+ buf2[parent_trimmed.len + "/package.json".len] = 0;
+ const json_path = buf2[0 .. parent_trimmed.len + "/package.json".len];
+ log.msgs.clearRetainingCapacity();
+ log.errors = 0;
+ log.warnings = 0;
+
+ const json_file = std.fs.cwd().openFileZ(
+ buf2[0 .. parent_trimmed.len + "/package.json".len :0].ptr,
+ .{ .mode = .read_only },
+ ) catch continue;
+ defer json_file.close();
+
+ const json_stat_size = try json_file.getEndPos();
+ const json_buf = try allocator.alloc(u8, json_stat_size + 64);
+ defer allocator.free(json_buf);
+ const json_len = try json_file.preadAll(json_buf, 0);
+ const json_source = bun.logger.Source.initPathString(json_path, json_buf[0..json_len]);
+ const json = try json_parser.ParseJSONUTF8(&json_source, log, allocator);
+
+ const prop = json.asProperty("workspaces") orelse continue;
+
+ const json_array = switch (prop.expr.data) {
+ .e_array => |arr| arr,
+ .e_object => |obj| if (obj.get("packages")) |packages| switch (packages.data) {
+ .e_array => |arr| arr,
+ else => break,
+ } else break,
+ else => break,
+ };
+ _ = Package.processWorkspaceNamesArray(
+ workspace_map,
+ allocator,
+ log,
+ json_array,
+ &json_source,
+ prop.loc,
+ null,
+ ) catch |err| {
+ return err;
+ };
+ return;
+ }
+
+ // if we were not able to find a workspace root, try globbing for package.json files
+
+ var walker = Glob.BunGlobWalker{};
+ var arena = std.heap.ArenaAllocator.init(allocator);
+ const walker_init_res = try walker.init(&arena, "**/package.json", true, true, false, true, true);
+ switch (walker_init_res) {
+ .err => |err| {
+ Output.prettyErrorln("Error: {}", .{err});
+ return;
+ },
+ else => {},
+ }
+ defer walker.deinit(true);
+
+ var iter = Glob.BunGlobWalker.Iterator{ .walker = &walker };
+ const iter_init_res = try iter.init();
+ switch (iter_init_res) {
+ .err => |err| {
+ Output.prettyErrorln("Error: {}", .{err});
+ return;
+ },
+ else => {},
+ }
+ defer iter.deinit();
+
+ while (true) {
+ const next = try iter.next();
+ const path = switch (next) {
+ .err => |err| {
+ Output.prettyErrorln("Error: {}", .{err});
+ continue;
+ },
+ .result => |path| path orelse break,
+ };
+
+ const json_file = std.fs.cwd().openFile(
+ path,
+ .{ .mode = .read_only },
+ ) catch {
+ continue;
+ };
+ defer json_file.close();
+
+ const json_stat_size = try json_file.getEndPos();
+ const json_buf = try allocator.alloc(u8, json_stat_size + 64);
+ defer allocator.free(json_buf);
+
+ const json_len = try json_file.preadAll(json_buf, 0);
+ const json_source = bun.logger.Source.initPathString(path, json_buf[0..json_len]);
+
+ var parser = try json_parser.PackageJSONVersionChecker.init(allocator, &json_source, log);
+ _ = try parser.parseExpr();
+ if (!parser.has_found_name) {
+ continue;
+ }
+ const entry = Package.WorkspaceMap.Entry{ .name = try allocator.dupe(u8, parser.found_name), .version = null, .name_loc = bun.logger.Loc.Empty };
+ const dirpath = std.fs.path.dirname(path) orelse continue;
+ try workspace_map.insert(try allocator.dupe(u8, dirpath), entry);
+ }
+}
+
+pub fn getFilteredPackages(ctx: bun.CLI.Command.Context, cwd: []const u8, paths: *std.ArrayList([]u8)) !void {
+ // TODO in the future we can try loading the lockfile to get the workspace information more quickly
+ // var manager = try PackageManager.init(ctx, PackageManager.Subcommand.pm);
+ // const load_lockfile = manager.lockfile.loadFromDisk(ctx.allocator, ctx.log, "bun.lockb");
+ // if (load_lockfile == .not_found) {
+
+ // find the paths of all projects that match this filter
+
+ var wsmap = Package.WorkspaceMap.init(ctx.allocator);
+ defer wsmap.deinit();
+ // find the root package.json of the workspace and load the child packages into workspace map
+ findWorkspaceMembers(ctx.allocator, ctx.log, &wsmap, cwd) catch |err| {
+ if (comptime bun.Environment.allow_assert) {
+ if (@errorReturnTrace()) |trace| {
+ std.debug.print("Error: {s}\n{}\n", .{ @errorName(err), trace });
+ }
+ }
+ Output.err(err, "Failed to find workspace root in {s}", .{cwd});
+ ctx.log.printForLogLevelColorsRuntime(Output.errorWriter(), Output.enable_ansi_colors) catch {};
+ Global.exit(1);
+ };
+
+ var pattern_stack = std.heap.stackFallback(4096, bun.default_allocator);
+ var pattern = std.ArrayList(u32).init(pattern_stack.get());
+ defer pattern.deinit();
+
+ // check each pattern against each package name
+ for (ctx.filters) |pattern_utf8_| {
+ var pattern_utf8 = pattern_utf8_;
+ var path_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
+
+ const is_file_pattern = pattern_utf8.len > 0 and pattern_utf8[0] == '.';
+ if (is_file_pattern) {
+ const parts = [_]string{pattern_utf8};
+ pattern_utf8 = bun.path.joinAbsStringBuf(cwd, &path_buf, &parts, .auto);
+ }
+
+ pattern.clearRetainingCapacity();
+ var codepointer_iter = strings.UnsignedCodepointIterator.init(pattern_utf8);
+ var cursor = strings.UnsignedCodepointIterator.Cursor{};
+ while (codepointer_iter.next(&cursor)) {
+ try pattern.append(cursor.c);
+ }
+ for (wsmap.keys(), wsmap.values()) |path, entry| {
+ const target = if (is_file_pattern) path else entry.name;
+ if (Glob.matchImpl(pattern.items, target)) {
+ try paths.append(try ctx.allocator.dupe(u8, path));
+ }
+ }
+ }
+}