A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
module Plugin
class JsManager
class Cache < ActiveSupport::CurrentAttributes
# Cache which persists for the duration of a request
attribute :request_cache
end
@url_glob_patterns = {}
# A plugin route map can mount on a core route, so the build needs these to derive its urls.
CORE_ROUTE_MAPS = {
"app-route-map.js" => "frontend/discourse/app/routes/app-route-map.js",
"admin-route-map.js" => "frontend/discourse/admin/routes/admin-route-map.js",
}.freeze
# Each plugin compiles on its own, so its report is written beside its
# manifest and the copies are merged into one asset the analyzer reads.
def self.optional_plugin_stub
"data:text/javascript,/* autogenerated missing optional plugin stub */const m=new Proxy({},{get:()=>null});export default new Proxy({},{get:()=>m});"
end
def self.required_plugin_stub(plugin_name)
message =
"Plugin '#{plugin_name}' is imported by another bundle, but it is not installed on this site. " \
"If this dependency is optional, import it with `with { discourseImport: \"optional\" }`."
"data:text/javascript, /* autogenerated missing required plugin stub */ export default null; throw new Error(#{message.to_json});"
end
def self.js_asset_exists?(plugin_directory_name)
get_set_cache("js_asset_exists_#{plugin_directory_name}") do
has_source_files_in_dir(plugin_directory_name, "assets/javascripts")
end
end
def self.admin_js_asset_exists?(plugin_directory_name)
get_set_cache("admin_js_asset_exists_#{plugin_directory_name}") do
has_source_files_in_dir(plugin_directory_name, "admin/assets/javascripts")
end
end
def self.test_js_asset_exists?(plugin_directory_name)
get_set_cache("test_js_asset_exists_#{plugin_directory_name}") do
has_source_files_in_dir(plugin_directory_name, "test/javascripts")
end
end
def self.read_manifest(plugin_directory_name)
get_set_cache("manifest_#{plugin_directory_name}") do
manifest_path =
"#{Rails.root.join("app/assets/generated/#{plugin_directory_name}/manifest.json")}"
JSON.parse(File.read(manifest_path))
rescue Errno::ENOENT
{}
end
end
# Logical path of each plugin's bundle analysis report, for the dev tool.
def self.bundle_analysis_assets
get_set_cache("bundle_analysis_assets") do
Discourse
.plugins
.filter_map do |plugin|
file =
Dir.glob(
"#{Rails.root.join("app/assets/generated/#{plugin.directory_name}/js/plugins", "*bundle-analysis*.json")}",
).first
[plugin.directory_name, logical_path(File.basename(file))] if file
end
.to_h
end
end
def self.logical_path(file_name)
"js/plugins/#{file_name.delete_suffix(".js")}"
end
def self.digested_logical_path_for(plugin_directory_name, entrypoint_name)
manifest_entry = read_manifest(plugin_directory_name)[entrypoint_name]
logical_path(manifest_entry["fileName"]) if manifest_entry
end
def self.import_paths_for(plugin_directory_name, entrypoint_name)
read_manifest(plugin_directory_name)[entrypoint_name]["imports"].map { logical_path(it) }
end
def self.external_plugin_imports(plugin_directory_name, entrypoint_name)
read_manifest(plugin_directory_name)[entrypoint_name]["externalPluginImports"]
end
# The first match wins, so the build emits the most specific glob first.
def self.route_bundle_for_path(plugin_directory_name, entrypoint_name, path)
return if path.nil?
bundles = read_manifest(plugin_directory_name).dig(entrypoint_name, "routeBundles")
bundle = bundles.to_a.find { |c| path.match?(url_glob_pattern(c["url"])) }
logical_path(bundle["fileName"]) if bundle
end
# Every url the build emits ends in `/*`, so a bundle covers its own route and everything
# beneath it. Within the rest, `*` is one segment and `**` is one or more, standing in for a
# splat route segment. A pattern only depends on its glob, so it never goes stale.
def self.url_glob_pattern(glob)
@url_glob_patterns[glob] ||= begin
pattern =
glob
.delete_suffix("/*")
.split("/")
.map do |segment|
case segment
when "**"
"[^/]+(?:/[^/]+)*"
when "*"
"[^/]+"
else
Regexp.escape(segment)
end
end
.join("/")
%r{\A#{pattern}(?:/.*)?\z}
end
end
private_class_method :url_glob_pattern
def compile!
log "Compiling #{Discourse.plugins.count} plugins..."
start = Time.now
if !GlobalSetting.mini_racer_single_threaded && AssetProcessor.booted?
raise "Cannot fork Plugin::JsManager for parallel compilation because AssetProcessor is already booted."
end
parallel_count = [Etc.nprocessors, 4].min
AssetProcessor.timeout = 120_000
Parallel.each(Discourse.plugins, in_processes: parallel_count) do |plugin|
compile_js_bundle(plugin)
end
log "Finished initial compilation of plugins in #{(Time.now - start).round(2)}s"
end
def compile_js_bundle(plugin)
base_output_dir = "#{Rails.root.join("app/assets/generated/#{plugin.directory_name}")}"
js_dir = "#{base_output_dir}/js/plugins"
map_dir = "#{base_output_dir}/map/plugins"
entrypoints = { "main" => "assets/javascripts", "admin" => "admin/assets/javascripts" }
entrypoints["test"] = "test/javascripts" if Rails.env.local? && !production_build?
tree = {}
entrypoints_config = {}
entrypoints.each do |name, js_path|
js_base = "#{plugin.directory}/#{js_path}"
files = Dir.glob("**/*", base: js_base)
next if files.empty?
entrypoints_config[name] = { modules: [] }
files.sort.each do |file|
full_path = File.join(js_base, file)
if File.file?(full_path)
normalized_file_path = file.sub(/\.js\.es6$/, ".js")
content = File.read(full_path)
content = AssetProcessor.append_es6_deprecation(content, file) if file.end_with?(
".js.es6",
)
tree[normalized_file_path] = content
if name == "test" && file.match(%r{/(acceptance|integration|unit)/})
if file.match?(/-test\.g?[jt]s$/)
entrypoints_config[name][:modules] << normalized_file_path
end
else
entrypoints_config[name][:modules] << normalized_file_path
end
end
end
end
return if entrypoints_config.empty?
frontend_config = plugin.about_json_metadata&.dig("frontend")
# Only a plugin that splits its own routes derives anything from these. Read from source, so
# plugin compilation does not wait on core's build. Being in `tree` puts them in the digest
# below, so a core route change rebuilds those plugins and no others.
if frontend_config&.dig("staticModules") && tree.keys.any? { it.end_with?("route-map.js") }
CORE_ROUTE_MAPS.each do |name, source_path|
tree["__core__/#{name}"] = File.read(Rails.root.join(source_path))
end
end
hex_digest =
Digest::SHA1.hexdigest(
[
*tree.keys,
*tree.values,
AssetProcessor::BASE_COMPILER_VERSION,
AssetProcessor.digest,
AssetProcessor.ember_version,
production_build?.to_s,
plugin.name,
frontend_config.to_json,
].join,
)
base36_digest = hex_digest.to_i(16).to_s(36).first(8)
filename_prefix = "#{plugin.directory_name}_"
filename_suffix = "-#{base36_digest}.digested"
existing_files = Dir.glob("#{js_dir}/*").map { |path| File.basename(path) }
files_exist =
entrypoints_config.keys.all? do |name|
existing_files.any? do |file|
file.start_with?("#{filename_prefix}#{name}.") &&
file.end_with?("#{filename_suffix}.js")
end
end
if !cache? || !files_exist
compiler =
Plugin::JsCompiler.new(
plugin.name,
minify: production_build?,
tree: tree,
entrypoints: entrypoints_config,
filename_prefix:,
filename_suffix:,
frontend_config:,
)
result = compiler.compile!
FileUtils.mkdir_p(js_dir)
FileUtils.mkdir_p(map_dir)
manifest = {}
analysis_chunks = {}
result.each do |file_name, info|
code = info["code"]
code += "\n//# sourceMappingURL=../../map/plugins/#{file_name}.map\n" if info["map"]
js_path = "#{js_dir}/#{file_name}"
File.write(js_path, code)
File.write("#{map_dir}/#{file_name}.map", info["map"]) if info["map"]
analysis_chunks[file_name] = {
file: file_name,
name: info["name"],
isEntry: info["isEntry"],
rawSize: code.bytesize,
brotliSize: (compress_to_brotli(js_path) if production_build?),
imports: info["imports"],
modules: info["modules"],
}
if info["isEntry"]
manifest[info["name"]] = {
fileName: file_name,
imports: info["imports"],
externalPluginImports: info["externalPluginImports"],
routeBundles: info["routeBundles"],
}
end
end
File.write("#{base_output_dir}/manifest.json", JSON.pretty_generate(manifest))
analysis_path = "#{js_dir}/#{filename_prefix}bundle-analysis#{filename_suffix}.json"
File.write(
analysis_path,
JSON.generate(
plugin: plugin.directory_name,
entrypoints: manifest.transform_values { it[:fileName] },
routeBundles: manifest.transform_values { it[:routeBundles] || [] },
chunks: analysis_chunks,
),
)
compress_to_brotli(analysis_path) if production_build?
end
# Delete any old versions
Dir
.glob("#{base_output_dir}/*/*/*")
.reject { |path| path.include?(filename_suffix) || path.include?("_extra") }
.each { |path| FileUtils.rm_rf(path) }
end
def watch
listener =
Listen.to(
*Discourse.plugins.map(&:directory),
{ ignore: [%r{/node_modules/}], only: /\.(gjs|js|hbs|ts|gts)\z/ },
) do |modified, added, removed|
changed_files = modified + added + removed
changed_plugins = Set.new
log "Changed files:"
changed_files.each do |file|
relative_path = Pathname.new(file).relative_path_from(Rails.root)
log "- #{relative_path}"
plugin = Discourse.plugins.find { |p| file.start_with?(p.resolved_dir) }
changed_plugins << plugin if plugin
end
log "Recompiling..."
start = Time.now
changed_plugins.each { |plugin| compile_js_bundle(plugin) }
log "Finished recompilation in #{(Time.now - start).round(2)}s"
MessageBus.publish("/file-change", ["refresh"])
rescue => e
log "Plugin JS watcher crashed \n#{e}"
end
begin
listener.start
compile!
yield
ensure
listener.stop
end
end
private
def production_build?
Rails.env.production? || ENV["EMBER_ENV"] == "production"
end
def compress_to_brotli(path)
system("brotli", "-f", "--quality=11", "-o", "#{path}.br.tmp", path, exception: true)
File.rename("#{path}.br.tmp", "#{path}.br")
File.size("#{path}.br")
rescue Errno::ENOENT
log "brotli is not installed, so #{File.basename(path)} has no compressed size"
nil
end
def cache?
true
end
def log(message)
STDERR.puts message
end
private_class_method def self.get_set_cache(key, &blk)
store =
if Rails.env.development?
Cache.request_cache ||= {}
else
@production_cache ||= {}
end
if store.key?(key)
store[key]
else
store[key] = blk.call
end
end
private_class_method def self.has_source_files_in_dir(plugin_directory_name, dir)
Dir.glob("plugins/#{plugin_directory_name}/#{dir}/**/*.{js,hbs,gjs,es6,ts,gts}") do
break true
end || false
end
end
end