@webiny/build-tools 0.0.0-unstable.0d717d18dd

package/packages/watchPackage.js

@@ -0,0 +1,39 @@
+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"),
+        import("@rsbuild/plugin-svgr")
+    ]);
+
+    const rslib = await createRslib({
+        cwd,
+        config: {
+            lib: [{ format: "esm", bundle: false }],
+            source: {
+                entry: ["./src/**/*.{ts,tsx,js,jsx}"],
+                alias: { "~": "./src" }
+            },
+            output: {
+                target: "web",
+                distPath: { root: "./dist" },
+                cleanDistPath: false,
+                sourceMap: { js: "source-map" }
+            },
+            plugins: [pluginSvgr({ mixedImport: true, svgrOptions: { exportType: "named" } })]
+        }
+    });
+
+    await rslib.build({ watch: true });
+};

package/traverseLoaders.js

@@ -0,0 +1,14 @@
+/**
+ * A utility to recursively traverse loaders and execute the "onLoader" callback.
+ */
+export const traverseLoaders = (loaders, onLoader) => {
+    for (const loader of loaders) {
+        if (loader.oneOf) {
+            traverseLoaders(loader.oneOf, onLoader);
+        } else if (loader.use) {
+            traverseLoaders(loader.use, onLoader);
+        } else {
+            onLoader(loader);
+        }
+    }
+};

package/utils/PackageJson.backup.ts

@@ -0,0 +1,45 @@
+// We'll use this class once the package is converted to TS!
+import { loadJsonFileSync } from "load-json-file";
+import { findUp } from "find-up";
+
+export class PackageJson {
+    private readonly filePath: string;
+    private readonly json: Record<string, any>;
+
+    static fromFile(filePath: string) {
+        return new PackageJson(filePath, loadJsonFileSync(filePath));
+    }
+
+    static async findClosest(fromPath: string) {
+        const closestPackageJson = await findUp("package.json", { cwd: fromPath });
+        if (!closestPackageJson) {
+            throw Error(`Failed to find ${fromPath}`);
+        }
+        return PackageJson.fromFile(closestPackageJson);
+    }
+
+    static async fromPackage(packageName: string, cwd?: string) {
+        const jsonPath = await findUp(`node_modules/${packageName}/package.json`, {
+            cwd: cwd ?? process.cwd()
+        });
+
+        if (!jsonPath) {
+            throw Error(`Failed to find package ${packageName}`);
+        }
+
+        return PackageJson.fromFile(jsonPath);
+    }
+
+    private constructor(filePath: string, json: Record<string, any>) {
+        this.filePath = filePath;
+        this.json = json;
+    }
+
+    getLocation() {
+        return this.filePath;
+    }
+
+    getJson() {
+        return this.json;
+    }
+}

package/utils/PackageJson.d.ts

@@ -0,0 +1,33 @@
+export declare class PackageJson {
+    private readonly filePath: string;
+    private readonly json: Record<string, any>;
+
+    private constructor(filePath: string, json: Record<string, any>);
+
+    /**
+     * Load a PackageJson instance from a given file path.
+     */
+    static fromFile(filePath: string): PackageJson;
+
+    /**
+     * Find the closest package.json starting from the given path.
+     * Throws if no package.json is found.
+     */
+    static findClosest(fromPath: string): Promise<PackageJson>;
+
+    /**
+     * Load a PackageJson instance from a package in node_modules.
+     * Throws if the package.json cannot be found.
+     */
+    static fromPackage(packageName: string, cwd?: string): Promise<PackageJson>;
+
+    /**
+     * Get the absolute path to this package.json file.
+     */
+    getLocation(): string;
+
+    /**
+     * Get the raw JSON contents of the package.json file.
+     */
+    getJson(): Record<string, any>;
+}

package/utils/PackageJson.js

@@ -0,0 +1,44 @@
+import { loadJsonFileSync } from "load-json-file";
+import { findUp } from "find-up";
+
+export class PackageJson {
+    filePath;
+    json;
+
+    static fromFile(filePath) {
+        return new PackageJson(filePath, loadJsonFileSync(filePath));
+    }
+
+    static async findClosest(fromPath) {
+        const closestPackageJson = await findUp("package.json", { cwd: fromPath });
+        if (!closestPackageJson) {
+            throw Error(`Failed to find ${fromPath}`);
+        }
+        return PackageJson.fromFile(closestPackageJson);
+    }
+
+    static async fromPackage(packageName, cwd) {
+        const jsonPath = await findUp(`node_modules/${packageName}/package.json`, {
+            cwd: cwd ?? process.cwd()
+        });
+
+        if (!jsonPath) {
+            throw Error(`Failed to find package ${packageName}`);
+        }
+
+        return PackageJson.fromFile(jsonPath);
+    }
+
+    constructor(filePath, json) {
+        this.filePath = filePath;
+        this.json = json;
+    }
+
+    getLocation() {
+        return this.filePath;
+    }
+
+    getJson() {
+        return this.json;
+    }
+}

package/utils.js

@@ -0,0 +1,33 @@
+import merge from "lodash/merge.js";
+
+/**
+ * Prepares the options object, sent to build and watch functions.
+ * @param config
+ * @param options
+ * @returns {Promise<{overrides}|*>}
+ */
+export const prepareOptions = ({ config, options }) => {
+    const mergedOptions = merge({}, config, options);
+
+    // If it doesn't exist, ensure `overrides` is an empty object.
+    if (!mergedOptions.overrides) {
+        mergedOptions.overrides = {};
+    }
+
+    // We want to have debug logs disabled by default.
+    mergedOptions.debug = mergedOptions.debug === true;
+
+    return mergedOptions;
+};
+
+/**
+ * Calculates time difference between the initial `getDuration`
+ * invocation and the invocation of the returned callback function.
+ * @returns {function(): string}
+ */
+export const getDuration = () => {
+    const start = new Date();
+    return () => {
+        return (new Date() - start) / 1000;
+    };
+};

package/workspaces/index.js

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

package/workspaces/linkWorkspaces.js

@@ -0,0 +1,100 @@
+/**
+ * This tool will re-link monorepo packages to one of the following directories (by priority):
+ * - {package}/package.json -> webiny.publishFrom
+ * - package root directory
+ */
+
+import "tsx";
+import { listWorkspaces } from "@webiny/stdlib/node";
+import path from "path";
+import get from "lodash/get.js";
+import fs from "fs-extra";
+import * as rimraf from "rimraf";
+
+async function symlink(src, dest) {
+    if (process.platform !== "win32") {
+        // use relative paths otherwise which will be retained if the directory is moved
+        src = path.relative(path.dirname(dest), src);
+        // When path.relative returns an empty string for the current directory, we should instead use
+        // '.', which is a valid fs.symlink target.
+        src = src || ".";
+    }
+
+    try {
+        const stats = await fs.lstat(dest);
+        if (stats.isSymbolicLink()) {
+            const resolved = dest;
+            if (resolved === src) {
+                return;
+            }
+        }
+    } catch (err) {
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+    }
+    // We use rimraf for unlink which never throws an ENOENT on missing target
+    rimraf.sync(dest);
+
+    if (process.platform === "win32") {
+        // use directory junctions if possible on win32, this requires absolute paths
+        await fs.symlink(src, dest, "junction");
+    } else {
+        await fs.symlink(src, dest);
+    }
+}
+
+const defaults = {
+    whitelist: [],
+    blacklist: []
+};
+
+export const linkWorkspaces = async ({ whitelist, blacklist } = defaults) => {
+    console.log(`Linking project workspaces...`);
+    const { PackageJson } = await import("../utils/PackageJson.js");
+
+    whitelist = (whitelist || []).map(p => path.resolve(p));
+    blacklist = (blacklist || []).map(p => path.resolve(p));
+    // Filter packages to only those in the whitelisted folders
+
+    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) {
+                return false;
+            } else if (whitelist.length === 0) {
+                return true;
+            }
+            return whitelist.some(w => pkg.startsWith(w));
+        });
+
+    for (let i = 0; i < packages.length; i++) {
+        const packageJson = path.resolve(packages[i], "package.json");
+        if (!fs.existsSync(packageJson)) {
+            continue;
+        }
+
+        const pkgJson = await PackageJson.fromFile(packageJson);
+        const pkg = pkgJson.getJson();
+
+        const targetDirectory = get(pkg, "webiny.publishFrom");
+        const link = path.resolve("node_modules", pkg.name);
+        const target = path.resolve(packages[i], targetDirectory || ".");
+
+        if (!fs.existsSync(target)) {
+            fs.mkdirpSync(target);
+        }
+
+        try {
+            await fs.mkdirp(path.dirname(link));
+            await symlink(target, link);
+        } catch (err) {
+            console.log(`Failed ${pkg.name}: ${err.message}`);
+        }
+    }
+};