@webiny/build-tools 6.4.11 → 6.6.0-alpha.1

package/bundling/admin/createRsbuildConfig.js

@@ -45,7 +45,12 @@ export const createRsbuildConfig = ({ cwd }) => {
                 }
             }
         },
-        server: { port: process.env.PORT || 3001, host: "0.0.0.0" },
+        // Port precedence matches the served admin app (`webiny serve admin`): an explicit
+        // WEBINY_ADMIN_PORT wins, then a PORT injected by the environment, then the 3001 default.
+        server: {
+            port: process.env.WEBINY_ADMIN_PORT || process.env.PORT || 3001,
+            host: "0.0.0.0"
+        },
         html: {
             template: paths.projectRootFolder + "/public/index.html"
         },
@@ -159,7 +164,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

@@ -2,7 +2,7 @@ import path from "path";
 import { pluginTypeCheck } from "@rsbuild/plugin-type-check";
 import { createImportValidatorPlugin } from "../importValidatorPlugin.js";
 
-const DEFAULT_WEBINY_INFRA_API_MAX_BUNDLE_SIZE = 4_718_592; // 4.5 MB
+const DEFAULT_WEBINY_INFRA_API_MAX_BUNDLE_SIZE = 6_291_456; // 6 MB
 
 export const createRsbuildConfig = async ({ cwd, enforceMaxBundleSize }) => {
     // Must be a dynamic import — see rslibCompile.js for the reason.
@@ -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 => {
@@ -41,6 +57,21 @@ export const createRsbuildConfig = async ({ cwd, enforceMaxBundleSize }) => {
         },
         tools: {
             rspack: {
+                output: {
+                    // Declares the entry's exports as the bundle's public API, so ALL of them survive.
+                    //
+                    // Nothing imports an entry's exports, so without this rspack treats any unused one
+                    // as dead: it dropped `streamHandler` AND every module reachable only from it. The
+                    // api bundle then exported just `handler` and contained zero streaming code, so the
+                    // response-streaming Lambda (`handler.streamHandler`) had no handler to load and
+                    // failed at cold start. `handler` survived only by accident of being first.
+                    //
+                    // To verify after changing anything here, grep the built bundle:
+                    //   .webiny/workspace/apps/api/graphql/build/_handler.mjs
+                    // It must export BOTH `handler` and `streamHandler`. Removing this line takes the
+                    // export count back to one — silently, with a green build.
+                    library: { type: "module" }
+                },
                 ...(enforceMaxBundleSize && {
                     performance: {
                         hints: "error",
@@ -48,13 +79,21 @@ 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.
+                    // Ignore optional `canvas` native module required by jsdom.
                     // https://rspack.dev/plugins/webpack/ignore-plugin
                     new rspack.IgnorePlugin({
-                        resourceRegExp: /canvas/,
-                        contextRegExp: /jsdom$/
+                        resourceRegExp: /^canvas$/,
+                        contextRegExp: /jsdom/
                     })
                 ],
                 resolve: {
@@ -63,7 +102,19 @@ export const createRsbuildConfig = async ({ cwd, enforceMaxBundleSize }) => {
                         // Not needed in Lambda environment and can cause bundling/deployment issues.
                         bufferutil: false
                     }
-                }
+                },
+                // bree's root-jobs loader does `await import(importUrl)` on a path it builds at runtime,
+                // which rspack can't resolve statically, so it reports a critical dependency. That import
+                // sits behind `if (this.config.root && ...)` (node_modules/bree/src/index.js), and
+                // BreeSchedulerService constructs Bree with `root: false` — the branch never runs, and
+                // nothing is missing from the bundle. Matched narrowly so a genuine expression-based
+                // import anywhere else still gets reported.
+                ignoreWarnings: [
+                    {
+                        module: /node_modules[\\/]bree[\\/]/,
+                        message: /Critical dependency: the request of a dependency is an expression/
+                    }
+                ]
             }
         },
         mode,

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.11",
+	"version": "6.6.0-alpha.1",
 	"type": "module",
 	"exports": {
 		".": "./index.js",
@@ -17,22 +17,22 @@
 		"Adrian Smijulj <adrian@webiny.com>"
 	],
 	"dependencies": {
-		"@rsbuild/core": "2.1.5",
+		"@rsbuild/core": "2.1.13",
 		"@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.2",
 		"@rslib/core": "0.23.2",
-		"@rspack/core": "2.1.3",
-		"@swc/plugin-emotion": "14.15.0",
-		"@tailwindcss/postcss": "4.3.2",
-		"chalk": "5.6.2",
+		"@rspack/core": "2.1.10",
+		"@swc/plugin-emotion": "15.0.0",
+		"@tailwindcss/postcss": "4.3.3",
+		"@webiny/stdlib": "0.0.17",
+		"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,14 +40,16 @@
 		"react-dom": "18.3.1",
 		"react-refresh": "0.18.0",
 		"rimraf": "6.1.3",
-		"sass": "1.101.0",
+		"sass": "1.103.1",
 		"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.12",
+		"typescript": "7.0.2",
 		"url-loader": "4.1.1",
-		"utf-8-validate": "6.0.6"
+		"utf-8-validate": "6.0.6",
+		"yargs": "18.1.0"
 	},
 	"license": "MIT",
 	"adio": {

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/testing/presets.d.ts

@@ -0,0 +1,6 @@
+interface Preset {
+    setupFiles?: string[];
+    setupFilesAfterEnv?: string[];
+}
+
+export function getPresets(...keywords: string[][]): Promise<Preset[]>;

package/testing/presets.js

@@ -0,0 +1,162 @@
+import path from "path";
+import fs from "fs";
+import { listWorkspaces } from "@webiny/stdlib/node";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { PackageJson } from "@webiny/build-tools/utils/PackageJson.js";
+
+const MIN_STORAGE_LENGTH = 1;
+const DEFAULT_STORAGE = "ddb";
+/**
+ * @param argv {string[]}
+ * @returns {string}
+ */
+const getStorage = argv => {
+    /**
+     * Storage is available in process.env?
+     */
+    const envValue = process.env.WEBINY_STORAGE;
+    if (typeof envValue === "string" && envValue.length > 2) {
+        return envValue;
+    }
+    /**
+     * This is if storage is available in args.
+     */
+    const args = yargs(argv);
+    const argsValue = args.storage;
+    if (typeof argsValue === "string" && argsValue.length > 2) {
+        return argsValue;
+    }
+    /**
+     * Then we try to get --storage=([a-z])
+     */
+    const matched = argv
+        .map(item => {
+            const matched = item.match(/^--storage=([^\s]+)$/);
+            return matched ? matched[1] : null;
+        })
+        .find(item => {
+            return !!item;
+        });
+    if (typeof matched === "string" && matched.length > MIN_STORAGE_LENGTH) {
+        return matched;
+    }
+    /**
+     * Last attempt is to find --storage and then take next index.
+     */
+    const index = argv.findIndex(item => {
+        return item === "--storage";
+    });
+    if (index === -1) {
+        return DEFAULT_STORAGE;
+    }
+    const value = argv[index + 1];
+    if (typeof value === "string" && value.length > MIN_STORAGE_LENGTH) {
+        return value;
+    }
+    return DEFAULT_STORAGE;
+};
+
+const getAllPackages = targetKeywords => {
+    const storage = getStorage(hideBin(process.argv));
+
+    if (!storage) {
+        throw Error(`Missing required --storage parameter!`);
+    }
+
+    // Set the storage type as an environment variable.
+    process.env.WEBINY_STORAGE_OPS = storage;
+
+    const storagePriority = storage.split(",");
+
+    const packages = listWorkspaces({
+        cwd: process.cwd()
+    })
+        .map(pkg => {
+            return pkg.path.replace(/\\/g, "/");
+        })
+        .filter(pkg => pkg.match(/\/packages\//) !== null);
+
+    // Find packages that match the given sets of tags.
+    const packageJsons = [];
+    for (const pkg of packages) {
+        const pkgJson = PackageJson.fromFile(pkg + "/package.json");
+        const { name, keywords = [] } = pkgJson.getJson();
+
+        for (const set of targetKeywords) {
+            if (set.every(tag => keywords.includes(tag))) {
+                packageJsons.push({
+                    path: pkg,
+                    name,
+                    keywords
+                });
+            }
+        }
+    }
+    // Now we need to filter based on the required storage type, but also use fallback, if possible.
+    const results = [];
+
+    for (const set of targetKeywords) {
+        for (const storage of storagePriority) {
+            const matchingPackage = packageJsons.find(pkg => {
+                return [...set, storage].every(tag => pkg.keywords.includes(tag));
+            });
+
+            if (matchingPackage) {
+                results.push(matchingPackage);
+                break;
+            }
+        }
+    }
+
+    return results;
+};
+
+const removeEmptyPreset = preset => {
+    if (!preset || Object.keys(preset).length === 0) {
+        return false;
+    }
+    return true;
+};
+
+const getPackagesPresets = async targetKeywords => {
+    if (!targetKeywords || targetKeywords.length === 0) {
+        throw new Error(`You must pass keywords to search for in the packages.`);
+    }
+
+    if (!Array.isArray(targetKeywords[0])) {
+        targetKeywords = [targetKeywords];
+    }
+
+    const packages = getAllPackages(targetKeywords);
+    if (packages.length === 0) {
+        return [];
+    }
+    const items = [];
+    /**
+     * We go through all available packages to build presets for them.
+     */
+    for (const pkg of packages) {
+        const presetsPath = path.join(pkg.path, "__tests__/__api__/presets.js");
+        if (!fs.existsSync(presetsPath)) {
+            throw new Error(`Missing presets.js of the "${pkg.name}" package: ${presetsPath}`);
+        }
+        /**
+         * We expect presets file to contain an array of presets.
+         * We do not check for the actual contents of the presets arrays since they can be quite different per package.
+         */
+        const presets = await import(presetsPath).then(m => m.default ?? m);
+        if (Array.isArray(presets) === false) {
+            throw new Error(`Presets in package "${pkg.name}" must be defined as an array.`);
+        } else if (presets.length === 0) {
+            throw new Error(`There are no presets in the file "${presetsPath}".`);
+        }
+
+        items.push(...presets.filter(removeEmptyPreset));
+    }
+    return items;
+};
+
+export const getPresets = async (...targetKeywords) => {
+    return getPackagesPresets(targetKeywords);
+};

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) {