@netlify/build-info 6.2.2 → 6.3.0

package/lib/detect-build-system.js

@@ -1,145 +0,0 @@
-import { readFileSync } from 'fs';
-import path from 'path';
-import { findUpSync } from 'find-up';
-export const detectBuildSystems = async (baseDir, rootDir) => {
-    const buildTools = Object.keys(BUILD_SYSTEMS);
-    const buildSystems = await Promise.all(buildTools.map(async (tool) => await BUILD_SYSTEMS[tool](baseDir, rootDir)));
-    return buildSystems.reduce((res, tool) => {
-        if (tool) {
-            res.push(tool);
-        }
-        return res;
-    }, []);
-};
-const BUILD_SYSTEMS = {
-    nx: async (baseDir, rootDir) => {
-        const nx = ['nx.json'];
-        const nxConfigPath = lookFor(nx, baseDir, rootDir);
-        if (nxConfigPath) {
-            const pkgJson = getPkgJson(nxConfigPath);
-            const { devDependencies } = pkgJson;
-            return {
-                name: 'nx',
-                version: devDependencies?.nx,
-            };
-        }
-    },
-    lerna: async (baseDir, rootDir) => {
-        const lerna = ['lerna.json'];
-        const lernaConfigPath = lookFor(lerna, baseDir, rootDir);
-        if (lernaConfigPath) {
-            const pkgJson = getPkgJson(lernaConfigPath);
-            const { devDependencies } = pkgJson;
-            return {
-                name: 'lerna',
-                version: devDependencies?.lerna,
-            };
-        }
-    },
-    turbo: async (baseDir, rootDir) => {
-        const turbo = ['turbo.json'];
-        const turboConfigPath = lookFor(turbo, baseDir, rootDir);
-        if (turboConfigPath) {
-            const pkgJson = getPkgJson(turboConfigPath);
-            const { devDependencies } = pkgJson;
-            return {
-                name: 'turbo',
-                version: devDependencies?.turbo,
-            };
-        }
-    },
-    rush: async (baseDir, rootDir) => {
-        const rush = ['rush.json'];
-        const rushConfigPath = lookFor(rush, baseDir, rootDir);
-        if (rushConfigPath) {
-            const pkgJson = getPkgJson(rushConfigPath);
-            const { devDependencies } = pkgJson;
-            return {
-                name: 'rush',
-                version: devDependencies?.rush,
-            };
-        }
-    },
-    lage: async (baseDir, rootDir) => {
-        const lage = ['lage.config.js'];
-        const lageConfigPath = lookFor(lage, baseDir, rootDir);
-        if (lageConfigPath) {
-            const pkgJson = getPkgJson(lageConfigPath);
-            const { devDependencies } = pkgJson;
-            return {
-                name: 'lage',
-                version: devDependencies?.lage,
-            };
-        }
-    },
-    pants: async (baseDir, rootDir) => {
-        const pants = ['pants.toml'];
-        const pantsConfigPath = lookFor(pants, baseDir, rootDir);
-        if (pantsConfigPath) {
-            return {
-                name: 'pants',
-            };
-        }
-    },
-    buck: async (baseDir, rootDir) => {
-        const buck = ['.buckconfig', 'BUCK'];
-        const buckConfigPath = lookFor(buck, baseDir, rootDir);
-        if (buckConfigPath) {
-            return {
-                name: 'buck',
-            };
-        }
-    },
-    gradle: async (baseDir, rootDir) => {
-        const gradle = ['build.gradle'];
-        const gradleConfigPath = lookFor(gradle, baseDir, rootDir);
-        if (gradleConfigPath) {
-            return {
-                name: 'gradle',
-            };
-        }
-    },
-    bazel: async (baseDir, rootDir) => {
-        const bazel = ['.bazelrc', 'WORKSPACE', 'WORKSPACE.bazel', 'BUILD.bazel'];
-        const bazelConfigPath = lookFor(bazel, baseDir, rootDir);
-        if (bazelConfigPath) {
-            return {
-                name: 'bazel',
-            };
-        }
-    },
-    nix: async (baseDir, rootDir) => {
-        const nix = ['default.nix', 'shell.nix', 'release.nix'];
-        const nixConfigPath = lookFor(nix, baseDir, rootDir);
-        if (nixConfigPath) {
-            return {
-                name: 'nix',
-            };
-        }
-    },
-    moon: async (baseDir, rootDir) => {
-        const moon = ['.moon'];
-        const moonConfigPath = lookFor(moon, baseDir, rootDir, 'directory');
-        if (moonConfigPath) {
-            const pkgJson = getPkgJson(moonConfigPath);
-            const { devDependencies } = pkgJson;
-            return {
-                name: 'moon',
-                version: devDependencies?.moon,
-            };
-        }
-    },
-};
-const lookFor = (configFile, baseDir, rootDir, type) => {
-    return findUpSync(configFile, { cwd: baseDir, stopAt: rootDir, type: type });
-};
-const getPkgJson = (configPath) => {
-    let pkgJson = {};
-    try {
-        pkgJson = JSON.parse(readFileSync(path.join(path.dirname(configPath), 'package.json'), 'utf-8'));
-    }
-    catch {
-        // noop
-    }
-    return pkgJson;
-};

package/lib/detect-package-manager.js

@@ -1,71 +0,0 @@
-import { readFileSync } from 'fs';
-import { basename } from 'path';
-import { findUp, findUpMultiple } from 'find-up';
-/** The definition of all available package managers */
-const AVAILABLE_PACKAGE_MANAGERS = {
-    ["yarn" /* PkgManager.YARN */]: {
-        name: "yarn" /* PkgManager.YARN */,
-        installCommand: 'yarn install',
-        lockFile: 'yarn.lock',
-        forceEnvironment: 'NETLIFY_USE_YARN',
-    },
-    ["pnpm" /* PkgManager.PNPM */]: {
-        name: "pnpm" /* PkgManager.PNPM */,
-        installCommand: 'pnpm install',
-        lockFile: 'pnpm-lock.yaml',
-        forceEnvironment: 'NETLIFY_USE_PNPM',
-    },
-    ["npm" /* PkgManager.NPM */]: {
-        name: "npm" /* PkgManager.NPM */,
-        installCommand: 'npm install',
-        lockFile: 'package-lock.json',
-    },
-};
-/**
- * generate a map out of key is lock file and value the package manager
- * this is to reduce the complexity in loops
- */
-const lockFileMap = Object.values(AVAILABLE_PACKAGE_MANAGERS).reduce((cur, pkgManager) => ({ ...cur, [pkgManager.lockFile]: pkgManager }), {});
-/**
- * Detects the used package manager based on
- * 1. packageManager field
- * 2. environment variable that forces the usage
- * 3. a lock file that is present in this directory or up in the tree for workspaces
- * @param cwd The current process working directory of the build
- * @param stopAt The repository root where it should stop looking up for package.json or lock files. (defaults to `path.parse(cwd).root`)
- * @returns The package manager that was detected
- */
-export const detectPackageManager = async (cwd, stopAt) => {
-    const pkgPaths = await findUpMultiple('package.json', { cwd, stopAt });
-    for (const pkgPath of pkgPaths) {
-        const { packageManager } = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-        if (packageManager) {
-            //
-            const [parsed] = packageManager.split('@');
-            if (AVAILABLE_PACKAGE_MANAGERS[parsed]) {
-                return AVAILABLE_PACKAGE_MANAGERS[parsed];
-            }
-        }
-    }
-    // the package manager can be enforced via an environment variable as well
-    for (const pkgManager of Object.values(AVAILABLE_PACKAGE_MANAGERS)) {
-        if (pkgManager.forceEnvironment && process.env[pkgManager.forceEnvironment] === 'true') {
-            return pkgManager;
-        }
-    }
-    // find the correct lock file the tree up
-    const lockFilePath = await findUp(Object.keys(lockFileMap), { cwd, stopAt });
-    // if we found a lock file and the usage is not prohibited through an environment variable
-    // return the found package manager
-    if (lockFilePath) {
-        const lockFile = basename(lockFilePath);
-        const pkgManager = lockFileMap[lockFile];
-        // check if it not got disabled
-        if (!(pkgManager.forceEnvironment && process.env[pkgManager.forceEnvironment] === 'false')) {
-            return pkgManager;
-        }
-    }
-    // always default to npm
-    // TODO: add some reporting here to log that we fall backed
-    return AVAILABLE_PACKAGE_MANAGERS["npm" /* PkgManager.NPM */];
-};

package/lib/get-build-info.d.ts

@@ -1,11 +0,0 @@
-import { ContextOptions } from './context.js';
-import { BuildSystem } from './detect-build-system.js';
-import { PkgManagerFields } from './detect-package-manager.js';
-import { WorkspaceInfo } from './workspaces.js';
-export type Info = {
-    jsWorkspaces?: WorkspaceInfo;
-    packageManager?: PkgManagerFields;
-    frameworks: unknown[];
-    buildSystems?: BuildSystem[];
-};
-export declare const getBuildInfo: (opts: ContextOptions) => Promise<Info>;

package/lib/get-build-info.js

@@ -1,34 +0,0 @@
-import { listFrameworks } from '@netlify/framework-info';
-import { getContext } from './context.js';
-import { detectBuildSystems } from './detect-build-system.js';
-import { detectPackageManager } from './detect-package-manager.js';
-import { getWorkspaceInfo } from './workspaces.js';
-export const getBuildInfo = async (opts) => {
-    const context = await getContext(opts);
-    let frameworks = [];
-    try {
-        // if the framework  detection is crashing we should not crash the build info and package-manager
-        // detection
-        frameworks = await listFrameworks({ projectDir: context.projectDir });
-    }
-    catch {
-        // TODO: build reporting to buildbot see: https://github.com/netlify/pillar-workflow/issues/1001
-        // noop
-    }
-    const info = { frameworks };
-    try {
-        info.buildSystems = await detectBuildSystems(context.projectDir, context.rootDir);
-    }
-    catch (error) {
-        // noop
-    }
-    // only if we find a root package.json we know this is a javascript workspace
-    if (Object.keys(context.rootPackageJson).length > 0) {
-        info.packageManager = await detectPackageManager(context.projectDir, context.rootDir);
-        const workspaceInfo = await getWorkspaceInfo(info.packageManager, context);
-        if (workspaceInfo) {
-            info.jsWorkspaces = workspaceInfo;
-        }
-    }
-    return info;
-};

package/lib/workspaces.d.ts

@@ -1,22 +0,0 @@
-import { PackageJson } from 'read-pkg';
-import type { Context } from './context.js';
-import { PkgManagerFields } from './detect-package-manager.js';
-export type WorkspaceInfo = {
-    /** if we are in the current workspace root or not */
-    isRoot: boolean;
-    /** the workspace root directory */
-    rootDir: string;
-    /** list of relative package paths inside the workspace */
-    packages: string[];
-};
-/**
- * Get a list of globs about all the packages inside a pnpm workspace
- * https://pnpm.io/pnpm-workspace_yaml
- */
-export declare const detectPnpmWorkspaceGlobs: (rootDir: string) => string[];
-export declare const detectNpmOrYarnWorkspaceGlobs: (pkgJson: PackageJson) => string[];
-/**
- * If it's a javascript workspace (npm, pnpm, yarn) it will retrieve a list of all
- * relative package paths and will indicate if it's the root of the workspace
- */
-export declare const getWorkspaceInfo: (packageManager: PkgManagerFields, context: Context) => Promise<undefined | WorkspaceInfo>;

package/lib/workspaces.js

@@ -1,56 +0,0 @@
-import { existsSync, readFileSync } from 'fs';
-import { join, relative } from 'path';
-import mapWorkspaces from '@npmcli/map-workspaces';
-import { parse } from 'yaml';
-/**
- * Get a list of globs about all the packages inside a pnpm workspace
- * https://pnpm.io/pnpm-workspace_yaml
- */
-export const detectPnpmWorkspaceGlobs = (rootDir) => {
-    const workspaceFile = join(rootDir, 'pnpm-workspace.yaml');
-    if (!existsSync(workspaceFile)) {
-        return [];
-    }
-    const { packages } = parse(readFileSync(workspaceFile, 'utf-8'));
-    return packages;
-};
-export const detectNpmOrYarnWorkspaceGlobs = (pkgJson) => {
-    if (Array.isArray(pkgJson.workspaces)) {
-        return pkgJson.workspaces;
-    }
-    if (typeof pkgJson.workspaces === 'object') {
-        return pkgJson.workspaces.packages || [];
-    }
-    return [];
-};
-/**
- * If it's a javascript workspace (npm, pnpm, yarn) it will retrieve a list of all
- * relative package paths and will indicate if it's the root of the workspace
- */
-export const getWorkspaceInfo = async (packageManager, context) => {
-    const rootDir = context.rootDir || context.projectDir;
-    const workspaceGlobs = packageManager.name === "pnpm" /* PkgManager.PNPM */
-        ? detectPnpmWorkspaceGlobs(rootDir)
-        : detectNpmOrYarnWorkspaceGlobs(context.rootPackageJson);
-    if (workspaceGlobs.length === 0) {
-        return;
-    }
-    const workspacesMap = await mapWorkspaces({
-        cwd: rootDir,
-        pkg: { workspaces: workspaceGlobs },
-    });
-    // make paths relative
-    const packages = [...workspacesMap.values()].map((p) => relative(rootDir, p));
-    // The provided project dir is a workspace package and not a different directory
-    // in a mono repository that is not part inside the npm workspaces
-    const isWorkspace = packages.find((path) => context.projectDir === join(rootDir, path));
-    // The project dir is a collection of workspaces itself
-    const isRoot = !context.rootDir;
-    if (isWorkspace || isRoot) {
-        return {
-            isRoot,
-            packages,
-            rootDir,
-        };
-    }
-};