@webiny/build-tools 6.4.5-beta.0 → 6.6.0-alpha.0

package/bundling/admin/createRsbuildConfig.js

@@ -159,7 +159,9 @@ const getEnvVars = () => {
     // Provide values one by one, not as a single process.env object,
     // because otherwise plugin will put a big JSON object every time process.env is used in code.
     // This way minifier also removes redundant code on prod (like if(process.env.NODE_ENV === 'development')).
-    const envVarsAsStrings = {};
+    const envVarsAsStrings = {
+        "process.env": "{}"
+    };
     for (const key of Object.keys(raw)) {
         envVarsAsStrings[`process.env.${key}`] = JSON.stringify(raw[key]);
     }

package/bundling/function/createRsbuildConfig.js

@@ -10,6 +10,11 @@ export const createRsbuildConfig = async ({ cwd, enforceMaxBundleSize }) => {
     const paths = getPaths(cwd);
     const mode = getMode();
     const isDebugEnabled = process.env.DEBUG === "true";
+    // NOTE: dirty for now — sniffing the hosting type off an env var here. Ideally the build config
+    // wouldn't know about hosting types at all: the caller (createBuildFunction, or the flavour's own
+    // build layer) would pass in the externals policy + assetPrefix as options, keeping this file
+    // hosting-agnostic. Good enough while the server hosting type is ALPHA; revisit when it settles.
+    const isServer = process.env.WEBINY_HOSTING_TYPE === "server";
 
     // Configurable via WEBINY_INFRA_API_MAX_BUNDLE_SIZE (bytes).
     // Only enforced during build — watch mode skips size checks.
@@ -19,12 +24,23 @@ export const createRsbuildConfig = async ({ cwd, enforceMaxBundleSize }) => {
 
     return /** @type {import("@rsbuild/core").RsbuildConfig} */ ({
         source: { entry: { index: paths.fn.entryFile } },
+        // Resolve chunk/asset URLs relative to the running module, not from an absolute root. The
+        // server's bg-tasks worker chunk is spawned via `new Worker(new URL("...", import.meta.url))`
+        // and rsbuild's default publicPath "/" turns that into an ABSOLUTE url ("/xyz.mjs"), which
+        // resolves to the filesystem root and can't be found. "auto" resolves it relative to the module
+        // (handler.mjs) instead, so the chunk loads from build/. publicPath comes from
+        // `output.assetPrefix` in production and `dev.assetPrefix` in development (watch runs
+        // `rsbuild.build({ watch: true })` under NODE_ENV=development), so set BOTH. Not gated to the
+        // server hosting type: AWS has no worker chunks so it's a no-op there, and for any other
+        // (async import) chunks "auto" is at least as correct as "/" (Lambda runs from its own dir too).
+        dev: { assetPrefix: "auto" },
         output: {
             module: true,
             target: "node",
+            assetPrefix: "auto",
             minify: true,
             sourceMap: {
-                js: isDebugEnabled ? "source-map" : false
+                js: isDebugEnabled || mode === "development" ? "source-map" : false
             },
             filename: {
                 js: pathData => {
@@ -48,7 +64,15 @@ export const createRsbuildConfig = async ({ cwd, enforceMaxBundleSize }) => {
                         maxAssetSize: maxBundleSize
                     }
                 }),
-                externals: [/^@aws-sdk/, /^aws-sdk$/, /^sharp$/],
+                // Both hosting types bundle; externalize only what genuinely can't be bundled.
+                // sharp is a native .node binary; knex statically require()s a driver for every SQL
+                // dialect (bundling pulls in uninstalled ones) and lazily loads only the configured
+                // one at runtime (e.g. better-sqlite3). AWS additionally externalizes aws-sdk (the
+                // Lambda runtime provides it). Server ships these in build/node_modules — the build's
+                // packaging step (CI/Linux) copies them, natives included.
+                externals: isServer
+                    ? [/^sharp$/, /^knex(\/|$)/]
+                    : [/^@aws-sdk/, /^aws-sdk$/, /^sharp$/, /^knex(\/|$)/],
                 plugins: [
                     // This is necessary to enable JSDOM usage in Lambda.
                     // https://rspack.dev/plugins/webpack/ignore-plugin

package/bundling/importValidatorPlugin.js

@@ -9,6 +9,7 @@ const whitelist = [
     "@webiny/cognito",
     "@webiny/auth0",
     "@webiny/okta",
+    "@webiny/self-hosted-auth",
     "@webiny/plugins",
     "@webiny/sdk",
     "@webiny/stdlib",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/build-tools",
-	"version": "6.4.5-beta.0",
+	"version": "6.6.0-alpha.0",
 	"type": "module",
 	"exports": {
 		".": "./index.js",
@@ -17,22 +17,22 @@
 		"Adrian Smijulj <adrian@webiny.com>"
 	],
 	"dependencies": {
-		"@rsbuild/core": "2.1.5",
+		"@rsbuild/core": "2.1.8",
 		"@rsbuild/plugin-react": "2.1.0",
 		"@rsbuild/plugin-sass": "2.0.1",
 		"@rsbuild/plugin-svgr": "2.0.5",
-		"@rsbuild/plugin-type-check": "1.5.0",
-		"@rsdoctor/rspack-plugin": "1.5.18",
+		"@rsbuild/plugin-type-check": "1.6.0",
+		"@rsdoctor/rspack-plugin": "1.6.1",
 		"@rslib/core": "0.23.2",
-		"@rspack/core": "2.1.3",
+		"@rspack/core": "2.1.5",
 		"@swc/plugin-emotion": "14.15.0",
-		"@tailwindcss/postcss": "4.3.2",
-		"chalk": "5.6.2",
+		"@tailwindcss/postcss": "4.3.3",
+		"@webiny/stdlib": "0.0.14",
+		"chalk": "6.0.0",
 		"css-loader": "7.1.4",
 		"fast-glob": "3.3.3",
 		"find-up": "8.0.0",
-		"fs-extra": "11.3.6",
-		"get-yarn-workspaces": "1.0.2",
+		"fs-extra": "11.4.0",
 		"load-json-file": "7.0.1",
 		"lodash": "4.18.1",
 		"postcss-loader": "8.2.1",
@@ -40,12 +40,13 @@
 		"react-dom": "18.3.1",
 		"react-refresh": "0.18.0",
 		"rimraf": "6.1.3",
-		"sass": "1.101.0",
+		"sass": "1.102.0",
 		"sass-loader": "17.0.0",
+		"strip-json-comments": "5.0.3",
 		"style-loader": "4.0.0",
 		"ts-morph": "28.0.0",
-		"tsx": "4.23.0",
-		"typescript": "6.0.3",
+		"tsx": "4.23.1",
+		"typescript": "7.0.2",
 		"url-loader": "4.1.1",
 		"utf-8-validate": "6.0.6"
 	},

package/packages/buildPackage/rslibCompile.js

@@ -6,7 +6,9 @@ import glob from "fast-glob";
 const COMPILE_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx"];
 const SKIP_EXTENSIONS = [".d.ts"];
 
-export const rslibCompile = async ({ cwd }) => {
+export const rslibCompile = async ({ cwd, outputDir }) => {
+    const distRoot = outputDir || path.join(cwd, "dist");
+
     // Copy non-compilable files (assets, json, graphql, etc.) as-is.
     const pattern = path.join(cwd, "src/**/*.*").replace(/\\/g, "/");
     const allFiles = glob.sync(pattern, { onlyFiles: true, dot: true });
@@ -16,7 +18,7 @@ export const rslibCompile = async ({ cwd }) => {
         const shouldSkip = SKIP_EXTENSIONS.some(ext => file.endsWith(ext));
 
         if (!shouldCompile || shouldSkip) {
-            const destPath = file.replace(path.join(cwd, "src"), path.join(cwd, "dist"));
+            const destPath = file.replace(path.join(cwd, "src"), distRoot);
             fs.mkdirSync(dirname(destPath), { recursive: true });
             fs.copyFileSync(file, destPath);
         }
@@ -44,7 +46,7 @@ export const rslibCompile = async ({ cwd }) => {
             },
             output: {
                 target: "web",
-                distPath: { root: "./dist" },
+                distPath: { root: path.relative(cwd, distRoot) || "." },
                 cleanDistPath: false,
                 sourceMap: { js: "source-map" },
                 // mixedImport emits each SVG as a static asset for the default URL

package/packages/buildPackage/tsCompile.js

@@ -1,99 +1,80 @@
-import { join } from "path";
-import ts from "typescript";
+import { join, resolve } from "path";
+import fs from "node:fs";
 import merge from "lodash/merge.js";
 import { replaceTscAliases } from "./tsAliasReplacer.js";
+import { getTscBinaryPath } from "./typescript/getTscBinaryPath.js";
+import { readTsConfig } from "./typescript/readTsConfig.js";
+import { runTsc } from "./typescript/runTsc.js";
+import { writeTempTsConfig } from "./typescript/writeTempTsConfig.js";
 
 export const tsCompile = async ({ cwd = "", overrides, debug, outputDir, checkOnly = false }) => {
-    // Normalize path separators to forward slashes for consistent behavior on Windows.
-    const normalizedCwd = cwd.replace(/\\/g, "/");
+    const normalizedCwd = cwd || process.cwd();
+    const tscPath = getTscBinaryPath();
 
-    const tsConfigPath = join(normalizedCwd, "tsconfig.build.json");
+    const originalConfigPath = join(normalizedCwd, "tsconfig.build.json");
+    let tsConfigPath = originalConfigPath;
+    let tempConfigPath = null;
+    let resolvedOutDir = null;
 
-    let { config: readTsConfig } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+    const hasOverrides = overrides?.tsConfig || outputDir;
 
-    if (overrides.tsConfig) {
-        if (typeof overrides.tsConfig === "function") {
-            readTsConfig = overrides.tsConfig(readTsConfig);
-        } else {
-            merge(readTsConfig, overrides.tsConfig);
-        }
-
-        if (debug) {
-            console.log(`"tsconfig.build.json" overridden. New config:`);
-            console.log(readTsConfig);
-        }
-    }
-    if (outputDir) {
-        readTsConfig.compilerOptions = readTsConfig.compilerOptions || {};
-        readTsConfig.compilerOptions.outDir = outputDir;
-        readTsConfig.compilerOptions.declarationDir = outputDir;
-    }
+    if (hasOverrides) {
+        let config = readTsConfig(originalConfigPath);
 
-    const parsedJsonConfigFile = ts.parseJsonConfigFileContent(readTsConfig, ts.sys, normalizedCwd);
+        if (overrides?.tsConfig) {
+            if (typeof overrides.tsConfig === "function") {
+                config = overrides.tsConfig(config);
+            } else {
+                merge(config, overrides.tsConfig);
+            }
 
-    const { projectReferences, options, fileNames, errors } = parsedJsonConfigFile;
+            if (debug) {
+                console.log(`"tsconfig.build.json" overridden. New config:`);
+                console.log(config);
+            }
+        }
 
-    const filteredFileNames = fileNames.filter(fileName => !fileName.endsWith(".d.ts"));
+        if (outputDir) {
+            config.compilerOptions = config.compilerOptions || {};
+            config.compilerOptions.outDir = outputDir;
+            config.compilerOptions.declarationDir = outputDir;
+        }
 
-    if (checkOnly) {
-        options.noEmit = true;
+        resolvedOutDir = config.compilerOptions?.outDir;
+        tempConfigPath = writeTempTsConfig(normalizedCwd, config);
+        tsConfigPath = tempConfigPath;
     }
 
-    const program = ts.createProgram({
-        projectReferences,
-        options,
-        rootNames: filteredFileNames,
-        configFileParsingDiagnostics: errors
-    });
-
-    if (checkOnly) {
-        const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(errors);
+    try {
+        const args = ["-p", tsConfigPath];
+        args.push("--tsBuildInfoFile", join(normalizedCwd, "tsconfig.build.tsbuildinfo"));
 
-        if (allDiagnostics.length) {
-            const formatHost = {
-                getCanonicalFileName: path => path,
-                getCurrentDirectory: () => normalizedCwd,
-                getNewLine: () => ts.sys.newLine
-            };
-            const message = ts.formatDiagnostics(allDiagnostics, formatHost);
-            if (message) {
-                throw { message };
-            }
-        }
-        return;
-    }
-
-    const { diagnostics, emitSkipped } = program.emit(
-        undefined, // targetSourceFile
-        (fileName, data, writeByteOrderMark) => {
-            // Only emit files within the current package directory.
-            // Normalize path separators to handle Windows backslashes vs forward slashes.
-            const normalizedFileName = fileName.replace(/\\/g, "/");
-            const relativePath = normalizedFileName.replace(normalizedCwd, "");
-            if (normalizedFileName.startsWith(normalizedCwd) && !relativePath.includes("../")) {
-                ts.sys.writeFile(fileName, data, writeByteOrderMark);
-            }
+        if (checkOnly) {
+            args.push("--noEmit");
         }
-    );
 
-    const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(diagnostics, errors);
-
-    if (allDiagnostics.length) {
-        const formatHost = {
-            getCanonicalFileName: path => path,
-            getCurrentDirectory: () => normalizedCwd,
-            getNewLine: () => ts.sys.newLine
-        };
-        const message = ts.formatDiagnostics(allDiagnostics, formatHost);
-        if (message) {
-            throw { message };
+        runTsc(tscPath, args, normalizedCwd);
+    } finally {
+        if (tempConfigPath) {
+            fs.rmSync(tempConfigPath, { force: true });
         }
     }
 
-    if (emitSkipped) {
-        throw { message: "TypeScript compilation failed." };
+    if (!checkOnly) {
+        const distDir =
+            outputDir || resolveDistDir(normalizedCwd, originalConfigPath, resolvedOutDir);
+        await replaceTscAliases({ distDir, cwd: normalizedCwd, debug });
     }
-
-    const distDir = outputDir || options.outDir || join(normalizedCwd, "dist");
-    await replaceTscAliases({ distDir, cwd: normalizedCwd, debug });
 };
+
+function resolveDistDir(cwd, configPath, overriddenOutDir) {
+    if (overriddenOutDir) {
+        return resolve(cwd, overriddenOutDir);
+    }
+    const config = readTsConfig(configPath);
+    const outDir = config.compilerOptions?.outDir;
+    if (outDir) {
+        return resolve(cwd, outDir);
+    }
+    return join(cwd, "dist");
+}

package/packages/buildPackage/typescript/getTscBinaryPath.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import fs from "node:fs";
+
+let cachedPath = null;
+
+export function getTscBinaryPath() {
+    if (cachedPath) {
+        return cachedPath;
+    }
+
+    const require = createRequire(import.meta.url);
+    const tsPackageJsonPath = require.resolve("typescript/package.json");
+    const tsDir = dirname(tsPackageJsonPath);
+
+    const platformPackage = "@typescript/typescript-" + process.platform + "-" + process.arch;
+
+    let platformPkgPath;
+    try {
+        const platformRequire = createRequire(join(tsDir, "package.json"));
+        platformPkgPath = platformRequire.resolve(platformPackage + "/package.json");
+    } catch {
+        throw new Error(
+            "Unable to resolve " +
+                platformPackage +
+                ". " +
+                "Either your platform is unsupported, or you are missing the package on disk."
+        );
+    }
+
+    const libDir = join(dirname(platformPkgPath), "lib");
+
+    let exe = join(libDir, "tsc");
+    if (process.platform === "win32") {
+        exe += ".exe";
+        if (exe.length >= 248) {
+            exe = "\\\\?\\" + exe;
+        }
+    }
+
+    if (!fs.existsSync(exe)) {
+        throw new Error("TypeScript native binary not found: " + exe);
+    }
+
+    cachedPath = exe;
+    return cachedPath;
+}

package/packages/buildPackage/typescript/readTsConfig.js

@@ -0,0 +1,8 @@
+import fs from "node:fs";
+import stripJsonComments from "strip-json-comments";
+
+export function readTsConfig(configPath) {
+    const content = fs.readFileSync(configPath, "utf8");
+    const stripped = stripJsonComments(content, { trailingCommas: true });
+    return JSON.parse(stripped);
+}

package/packages/buildPackage/typescript/runTsc.js

@@ -0,0 +1,15 @@
+import { execFileSync } from "node:child_process";
+
+export function runTsc(tscPath, args, cwd) {
+    try {
+        execFileSync(tscPath, args, {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024
+        });
+    } catch (error) {
+        const output = [error.stdout, error.stderr].filter(Boolean).join("\n").trim();
+        throw { message: output || error.message || "TypeScript compilation failed." };
+    }
+}

package/packages/buildPackage/typescript/writeTempTsConfig.js

@@ -0,0 +1,10 @@
+import { join } from "node:path";
+import fs from "node:fs";
+import { randomBytes } from "node:crypto";
+
+export function writeTempTsConfig(cwd, config) {
+    const suffix = randomBytes(4).toString("hex");
+    const tempPath = join(cwd, `tsconfig.build.tmp-${suffix}.json`);
+    fs.writeFileSync(tempPath, JSON.stringify(config, null, 2), "utf8");
+    return tempPath;
+}

package/packages/buildPackage.js

@@ -69,7 +69,7 @@ async function buildWithSafeReplace(options, distDir) {
 
     const stagingOptions = { ...options, outputDir: stagingDir };
 
-    await babelCompile(stagingOptions);
+    await rslibCompile(stagingOptions);
     await tsCompile(stagingOptions);
 
     stagingOptions.logs !== false && console.log("Copying meta files...");

package/packages/watchPackage.js

@@ -1,6 +1,16 @@
+import fs from "node:fs";
+import { join } from "node:path";
+
 export default async options => {
     const { cwd } = options;
 
+    // Invalidate the build-cache freshness marker (see scripts/buildPackages
+    // distBuildHash.ts, ".webiny-build-hash"). Watch writes into dist without
+    // updating that marker, so its contents no longer match the last full
+    // build — a later `yarn build` must restore/rebuild instead of trusting the
+    // marker and skipping the cache→dist copy.
+    fs.rmSync(join(cwd, "dist", ".webiny-build-hash"), { force: true });
+
     // Must be a dynamic import — see rslibCompile.js for the reason.
     const [{ createRslib }, { pluginSvgr }] = await Promise.all([
         import("@rslib/core"),

package/workspaces/index.js

@@ -1,12 +1,15 @@
 import fs from "fs";
 import path from "path";
-import getYarnWorkspaces from "get-yarn-workspaces";
+import { listWorkspaces } from "@webiny/stdlib/node";
 export { linkWorkspaces } from "./linkWorkspaces";
 
 const hasPackageJson = p => fs.existsSync(p + "/package.json");
 
 export const allWorkspaces = () => {
-    return getYarnWorkspaces()
+    return listWorkspaces()
+        .map(pkg => {
+            return pkg.path;
+        })
         .filter(hasPackageJson)
         .map(pkg => pkg.replace(/\//g, path.sep));
 };

package/workspaces/linkWorkspaces.js

@@ -5,7 +5,7 @@
  */
 
 import "tsx";
-
+import { listWorkspaces } from "@webiny/stdlib/node";
 import path from "path";
 import get from "lodash/get.js";
 import fs from "fs-extra";
@@ -56,9 +56,13 @@ export const linkWorkspaces = async ({ whitelist, blacklist } = defaults) => {
     whitelist = (whitelist || []).map(p => path.resolve(p));
     blacklist = (blacklist || []).map(p => path.resolve(p));
     // Filter packages to only those in the whitelisted folders
-    const getYarnWorkspaces = await import("get-yarn-workspaces").then(m => m.default ?? m);
-    const packages = getYarnWorkspaces(process.cwd())
-        .map(pkg => pkg.replace(/\//g, path.sep))
+
+    const packages = listWorkspaces({
+        cwd: process.cwd()
+    })
+        .map(pkg => {
+            return pkg.path.replace(/\//g, path.sep);
+        })
         .filter(pkg => {
             const isBlacklisted = blacklist.some(b => pkg.startsWith(b));
             if (isBlacklisted) {