482 lines
17 KiB
Python
482 lines
17 KiB
Python
"""Repository-rule based bun_install implementation."""
|
|
|
|
_DEFAULT_INSTALL_INPUTS = [
|
|
".npmrc",
|
|
"bunfig.json",
|
|
"bunfig.toml",
|
|
]
|
|
|
|
_MANIFEST_DEP_FIELDS = [
|
|
"dependencies",
|
|
"devDependencies",
|
|
"optionalDependencies",
|
|
"peerDependencies",
|
|
]
|
|
|
|
def _normalize_path(path):
|
|
normalized = path.replace("\\", "/")
|
|
if normalized.endswith("/") and normalized != "/":
|
|
normalized = normalized[:-1]
|
|
return normalized
|
|
|
|
def _relative_to_root(root, child):
|
|
normalized_root = _normalize_path(root)
|
|
normalized_child = _normalize_path(child)
|
|
|
|
if normalized_child == normalized_root:
|
|
return ""
|
|
|
|
prefix = normalized_root + "/"
|
|
if not normalized_child.startswith(prefix):
|
|
fail("bun_install: expected install input {} to be under {}".format(child, root))
|
|
|
|
return normalized_child[len(prefix):]
|
|
|
|
def _segment_matches(name, pattern):
|
|
if pattern == "*":
|
|
return True
|
|
|
|
if "*" not in pattern:
|
|
return name == pattern
|
|
|
|
parts = pattern.split("*")
|
|
if len(parts) == 1:
|
|
return name == pattern
|
|
|
|
pos = 0
|
|
anchored_start = not pattern.startswith("*")
|
|
anchored_end = not pattern.endswith("*")
|
|
|
|
for i, part in enumerate(parts):
|
|
if not part:
|
|
continue
|
|
|
|
match_index = name.find(part, pos)
|
|
if match_index < 0:
|
|
return False
|
|
|
|
if i == 0 and anchored_start and match_index != 0:
|
|
return False
|
|
|
|
pos = match_index + len(part)
|
|
|
|
if anchored_end and parts[-1] and not name.endswith(parts[-1]):
|
|
return False
|
|
|
|
return True
|
|
|
|
def _walk_workspace_dirs(root, segments):
|
|
matches = [root]
|
|
|
|
for segment in segments:
|
|
if segment == "**":
|
|
fail("bun_install: `**` is not supported in workspace patterns; use explicit segments or `*`")
|
|
|
|
next_matches = []
|
|
for parent in matches:
|
|
for child in parent.readdir():
|
|
if child.is_dir and _segment_matches(child.basename, segment):
|
|
next_matches.append(child)
|
|
|
|
matches = next_matches
|
|
|
|
return matches
|
|
|
|
def _workspace_patterns(repository_ctx, package_json):
|
|
manifest = json.decode(repository_ctx.read(package_json))
|
|
workspaces = manifest.get("workspaces", [])
|
|
|
|
if type(workspaces) == type({}):
|
|
workspaces = workspaces.get("packages", [])
|
|
|
|
if type(workspaces) != type([]):
|
|
fail("bun_install: `workspaces` must be a list or an object with a `packages` list")
|
|
|
|
patterns = []
|
|
for pattern in workspaces:
|
|
if type(pattern) != type(""):
|
|
fail("bun_install: workspace pattern must be a string, got {}".format(type(pattern)))
|
|
|
|
normalized = "/".join([segment for segment in pattern.split("/") if segment and segment != "."])
|
|
if normalized:
|
|
patterns.append(normalized)
|
|
|
|
return patterns
|
|
|
|
def _validate_catalog_shape(field, value):
|
|
if value == None:
|
|
return
|
|
|
|
if type(value) != type({}):
|
|
fail("bun_install: `{}` must be an object".format(field))
|
|
|
|
if field not in ["catalogs", "workspaces.catalogs"]:
|
|
return
|
|
|
|
for name, catalog in value.items():
|
|
if type(name) != type(""):
|
|
fail("bun_install: `catalogs` keys must be strings, got {}".format(type(name)))
|
|
if type(catalog) != type({}):
|
|
fail("bun_install: `catalogs.{}` must be an object".format(name))
|
|
|
|
def _copy_json_value(value):
|
|
return json.decode(json.encode(value))
|
|
|
|
def _package_target_name(package_name):
|
|
sanitized = package_name
|
|
sanitized = sanitized.replace("@", "at_")
|
|
sanitized = sanitized.replace("/", "_")
|
|
sanitized = sanitized.replace("-", "_")
|
|
sanitized = sanitized.replace(".", "_")
|
|
sanitized = sanitized.replace("__", "_").replace("__", "_").replace("__", "_")
|
|
sanitized = sanitized.strip("_")
|
|
if not sanitized:
|
|
sanitized = "package"
|
|
return "npm__" + sanitized
|
|
|
|
def _manifest_dependency_names(manifest):
|
|
names = {}
|
|
for field in _MANIFEST_DEP_FIELDS:
|
|
dependencies = manifest.get(field)
|
|
if dependencies == None:
|
|
continue
|
|
if type(dependencies) != type({}):
|
|
fail("bun_install: `{}` must be an object when present".format(field))
|
|
for name in dependencies.keys():
|
|
names[name] = True
|
|
return names
|
|
|
|
def _normalized_root_manifest(repository_ctx, package_json):
|
|
manifest = json.decode(repository_ctx.read(package_json))
|
|
workspaces = manifest.get("workspaces")
|
|
|
|
for field in ["catalog", "catalogs"]:
|
|
manifest_value = manifest.get(field)
|
|
_validate_catalog_shape(field, manifest_value)
|
|
|
|
if type(workspaces) != type({}):
|
|
continue
|
|
|
|
workspace_value = workspaces.get(field)
|
|
_validate_catalog_shape("workspaces.{}".format(field), workspace_value)
|
|
|
|
if workspace_value == None:
|
|
continue
|
|
|
|
if manifest_value == None:
|
|
manifest[field] = _copy_json_value(workspace_value)
|
|
continue
|
|
|
|
if manifest_value != workspace_value:
|
|
fail(
|
|
"bun_install: `{}` conflicts with `workspaces.{}`; use one source of truth or keep both values identical".format(field, field),
|
|
)
|
|
|
|
return json.encode(manifest)
|
|
|
|
def _materialize_workspace_packages(repository_ctx, package_json):
|
|
package_root = package_json.dirname
|
|
package_root_str = str(package_root)
|
|
written = {}
|
|
workspace_packages = {}
|
|
|
|
for pattern in _workspace_patterns(repository_ctx, package_json):
|
|
segments = pattern.split("/")
|
|
for workspace_dir in _walk_workspace_dirs(package_root, segments):
|
|
workspace_package_json = repository_ctx.path(str(workspace_dir) + "/package.json")
|
|
if not workspace_package_json.exists:
|
|
continue
|
|
|
|
workspace_dir_str = str(workspace_dir)
|
|
if workspace_dir_str == package_root_str:
|
|
continue
|
|
|
|
relative_dir = _relative_to_root(package_root_str, workspace_dir_str)
|
|
if relative_dir in written:
|
|
continue
|
|
|
|
repository_ctx.file(
|
|
relative_dir + "/package.json",
|
|
repository_ctx.read(workspace_package_json),
|
|
)
|
|
written[relative_dir] = True
|
|
manifest = json.decode(repository_ctx.read(workspace_package_json))
|
|
package_name = manifest.get("name")
|
|
workspace_packages[relative_dir] = package_name if type(package_name) == type("") else ""
|
|
|
|
package_dirs = sorted(workspace_packages.keys())
|
|
package_names_by_dir = {}
|
|
for package_dir in package_dirs:
|
|
package_name = workspace_packages[package_dir]
|
|
if package_name:
|
|
package_names_by_dir[package_dir] = package_name
|
|
return struct(
|
|
package_dirs = package_dirs,
|
|
package_names_by_dir = package_names_by_dir,
|
|
package_names = [workspace_packages[package_dir] for package_dir in package_dirs if workspace_packages[package_dir]],
|
|
)
|
|
|
|
def _materialize_install_inputs(repository_ctx, package_json):
|
|
package_root = package_json.dirname
|
|
package_root_str = str(package_root)
|
|
written = {}
|
|
|
|
for relative_path in _DEFAULT_INSTALL_INPUTS:
|
|
source_path = repository_ctx.path(str(package_root) + "/" + relative_path)
|
|
if source_path.exists and not source_path.is_dir:
|
|
repository_ctx.file(relative_path, repository_ctx.read(source_path))
|
|
written[relative_path] = True
|
|
|
|
for install_input in repository_ctx.attr.install_inputs:
|
|
source_path = repository_ctx.path(install_input)
|
|
|
|
if not source_path.exists:
|
|
fail("bun_install: install input not found: {}".format(install_input))
|
|
|
|
if source_path.is_dir:
|
|
fail("bun_install: install_inputs must be files under the package root: {}".format(install_input))
|
|
|
|
relative_path = _relative_to_root(package_root_str, str(source_path))
|
|
if not relative_path:
|
|
fail("bun_install: install input must be a file under the package root: {}".format(install_input))
|
|
|
|
if relative_path in written:
|
|
continue
|
|
|
|
repository_ctx.file(relative_path, repository_ctx.read(source_path))
|
|
written[relative_path] = True
|
|
|
|
def _select_bun_binary(repository_ctx):
|
|
os_name = repository_ctx.os.name.lower()
|
|
arch = repository_ctx.os.arch.lower()
|
|
|
|
if "linux" in os_name:
|
|
if arch in ["aarch64", "arm64"]:
|
|
return repository_ctx.path(repository_ctx.attr.bun_linux_aarch64)
|
|
return repository_ctx.path(repository_ctx.attr.bun_linux_x64)
|
|
|
|
if "mac" in os_name or "darwin" in os_name:
|
|
if arch in ["aarch64", "arm64"]:
|
|
return repository_ctx.path(repository_ctx.attr.bun_darwin_aarch64)
|
|
return repository_ctx.path(repository_ctx.attr.bun_darwin_x64)
|
|
|
|
if "windows" in os_name:
|
|
return repository_ctx.path(repository_ctx.attr.bun_windows_x64)
|
|
|
|
fail("Unsupported host platform: os={}, arch={}".format(repository_ctx.os.name, repository_ctx.os.arch))
|
|
|
|
def _render_package_targets_file(package_names):
|
|
lines = ["NPM_PACKAGE_TARGETS = {"]
|
|
for package_name in package_names:
|
|
lines.append(' "{}": "{}",'.format(package_name, _package_target_name(package_name)))
|
|
lines.extend([
|
|
"}",
|
|
"",
|
|
])
|
|
return "\n".join(lines)
|
|
|
|
def _render_repo_defs_bzl(repo_name):
|
|
return """load(":packages.bzl", "NPM_PACKAGE_TARGETS")
|
|
|
|
def package_target_name(package_name):
|
|
return NPM_PACKAGE_TARGETS.get(package_name)
|
|
|
|
def npm_link_all_packages(name = "node_modules", imported_links = []):
|
|
if not native.existing_rule(name):
|
|
native.alias(
|
|
name = name,
|
|
actual = "@{repo_name}//:node_modules",
|
|
)
|
|
|
|
requested = {{}}
|
|
for package_name in imported_links:
|
|
requested[package_name] = True
|
|
|
|
for package_name, target_name in NPM_PACKAGE_TARGETS.items():
|
|
if imported_links and package_name not in requested:
|
|
continue
|
|
if native.existing_rule(target_name):
|
|
continue
|
|
native.alias(
|
|
name = target_name,
|
|
actual = "@{repo_name}//:%s" % target_name,
|
|
)
|
|
""".format(repo_name = repo_name)
|
|
|
|
def _render_repo_build(package_names):
|
|
lines = [
|
|
'exports_files(["defs.bzl", "packages.bzl"])',
|
|
"",
|
|
"filegroup(",
|
|
' name = "node_modules",',
|
|
' srcs = glob(["**/node_modules/**"], allow_empty = False),',
|
|
' visibility = ["//visibility:public"],',
|
|
")",
|
|
"",
|
|
]
|
|
|
|
for package_name in package_names:
|
|
lines.extend([
|
|
"filegroup(",
|
|
' name = "{}",'.format(_package_target_name(package_name)),
|
|
' srcs = glob(["node_modules/{}/**"], allow_empty = True),'.format(package_name),
|
|
' visibility = ["//visibility:public"],',
|
|
")",
|
|
"",
|
|
])
|
|
|
|
return "\n".join(lines)
|
|
|
|
def _bun_install_repository_impl(repository_ctx):
|
|
package_json = repository_ctx.path(repository_ctx.attr.package_json)
|
|
bun_lockfile = repository_ctx.path(repository_ctx.attr.bun_lockfile)
|
|
|
|
if not package_json.exists:
|
|
fail("bun_install: package_json not found: {}".format(repository_ctx.attr.package_json))
|
|
|
|
if not bun_lockfile.exists:
|
|
fail("bun_install: bun_lockfile not found: {}".format(repository_ctx.attr.bun_lockfile))
|
|
|
|
bun_bin = _select_bun_binary(repository_ctx)
|
|
lockfile_name = bun_lockfile.basename
|
|
root_manifest = json.decode(repository_ctx.read(package_json))
|
|
|
|
if lockfile_name not in ["bun.lock", "bun.lockb"]:
|
|
lockfile_name = "bun.lock"
|
|
|
|
repository_ctx.file("package.json", _normalized_root_manifest(repository_ctx, package_json))
|
|
repository_ctx.symlink(bun_lockfile, lockfile_name)
|
|
_materialize_install_inputs(repository_ctx, package_json)
|
|
workspace_packages = _materialize_workspace_packages(repository_ctx, package_json)
|
|
|
|
install_args = [str(bun_bin), "--bun", "install", "--frozen-lockfile", "--no-progress"]
|
|
if repository_ctx.attr.production:
|
|
install_args.append("--production")
|
|
for omit in repository_ctx.attr.omit:
|
|
install_args.extend(["--omit", omit])
|
|
if repository_ctx.attr.linker:
|
|
install_args.extend(["--linker", repository_ctx.attr.linker])
|
|
if repository_ctx.attr.backend:
|
|
install_args.extend(["--backend", repository_ctx.attr.backend])
|
|
if repository_ctx.attr.ignore_scripts:
|
|
install_args.append("--ignore-scripts")
|
|
install_args.extend(repository_ctx.attr.install_flags)
|
|
if repository_ctx.attr.isolated_home:
|
|
result = repository_ctx.execute(
|
|
install_args,
|
|
timeout = 600,
|
|
quiet = False,
|
|
environment = {"HOME": str(repository_ctx.path("."))},
|
|
)
|
|
else:
|
|
result = repository_ctx.execute(
|
|
install_args,
|
|
timeout = 600,
|
|
quiet = False,
|
|
)
|
|
|
|
if result.return_code:
|
|
fail("""bun_install failed running `bun --bun install --frozen-lockfile`.
|
|
stdout:
|
|
{}
|
|
stderr:
|
|
{}
|
|
""".format(result.stdout, result.stderr))
|
|
|
|
repository_ctx.file(
|
|
"node_modules/.rules_bun/install.json",
|
|
json.encode({
|
|
"bun_lockfile": lockfile_name,
|
|
"install_root_rel_dir": ".",
|
|
"package_json": "package.json",
|
|
"workspace_package_dirs": workspace_packages.package_dirs,
|
|
"workspace_package_names_by_dir": workspace_packages.package_names_by_dir,
|
|
}) + "\n",
|
|
)
|
|
|
|
package_names = {}
|
|
for package_name in _manifest_dependency_names(root_manifest).keys():
|
|
package_names[package_name] = True
|
|
for package_name in workspace_packages.package_names:
|
|
package_names[package_name] = True
|
|
|
|
sorted_package_names = sorted(package_names.keys())
|
|
visible_repo_name = repository_ctx.attr.visible_repo_name or repository_ctx.name
|
|
repository_ctx.file("packages.bzl", _render_package_targets_file(sorted_package_names))
|
|
repository_ctx.file("defs.bzl", _render_repo_defs_bzl(visible_repo_name))
|
|
repository_ctx.file("BUILD.bazel", _render_repo_build(sorted_package_names))
|
|
|
|
bun_install_repository = repository_rule(
|
|
implementation = _bun_install_repository_impl,
|
|
attrs = {
|
|
"package_json": attr.label(mandatory = True, allow_single_file = True),
|
|
"bun_lockfile": attr.label(mandatory = True, allow_single_file = True),
|
|
"install_inputs": attr.label_list(allow_files = True),
|
|
"isolated_home": attr.bool(default = True),
|
|
"production": attr.bool(default = False),
|
|
"omit": attr.string_list(),
|
|
"linker": attr.string(),
|
|
"backend": attr.string(),
|
|
"ignore_scripts": attr.bool(default = True),
|
|
"install_flags": attr.string_list(),
|
|
"visible_repo_name": attr.string(),
|
|
"bun_linux_x64": attr.label(default = "@bun_linux_x64//:bun-linux-x64/bun", allow_single_file = True),
|
|
"bun_linux_aarch64": attr.label(default = "@bun_linux_aarch64//:bun-linux-aarch64/bun", allow_single_file = True),
|
|
"bun_darwin_x64": attr.label(default = "@bun_darwin_x64//:bun-darwin-x64/bun", allow_single_file = True),
|
|
"bun_darwin_aarch64": attr.label(default = "@bun_darwin_aarch64//:bun-darwin-aarch64/bun", allow_single_file = True),
|
|
"bun_windows_x64": attr.label(default = "@bun_windows_x64//:bun-windows-x64/bun.exe", allow_single_file = True),
|
|
},
|
|
)
|
|
|
|
def bun_install(
|
|
name,
|
|
package_json,
|
|
bun_lockfile,
|
|
install_inputs = [],
|
|
isolated_home = True,
|
|
production = False,
|
|
omit = [],
|
|
linker = "",
|
|
backend = "",
|
|
ignore_scripts = True,
|
|
install_flags = []):
|
|
"""Create an external repository containing installed node_modules.
|
|
|
|
Args:
|
|
name: Repository name to create.
|
|
package_json: Label to a package.json file.
|
|
bun_lockfile: Label to a bun.lockb file.
|
|
install_inputs: Optional additional files under the package root to copy
|
|
into the install context, such as patch files or auth/config files.
|
|
isolated_home: Whether to run Bun with HOME set to the generated
|
|
repository root for a more isolated install context.
|
|
production: Whether to omit devDependencies during install.
|
|
omit: Optional Bun dependency groups to omit, such as `dev` or `peer`.
|
|
linker: Optional Bun linker strategy, such as `isolated` or `hoisted`.
|
|
backend: Optional Bun install backend, such as `hardlink` or `copyfile`.
|
|
ignore_scripts: Whether to skip lifecycle scripts in the project manifest.
|
|
install_flags: Additional raw flags forwarded to `bun install`.
|
|
|
|
Usage (WORKSPACE):
|
|
bun_install(
|
|
name = "node_modules",
|
|
package_json = "//:package.json",
|
|
bun_lockfile = "//:bun.lockb",
|
|
)
|
|
"""
|
|
|
|
bun_install_repository(
|
|
name = name,
|
|
package_json = package_json,
|
|
bun_lockfile = bun_lockfile,
|
|
install_inputs = install_inputs,
|
|
isolated_home = isolated_home,
|
|
production = production,
|
|
omit = omit,
|
|
linker = linker,
|
|
backend = backend,
|
|
ignore_scripts = ignore_scripts,
|
|
install_flags = install_flags,
|
|
visible_repo_name = name,
|
|
)
|