@netlify/build-info 6.0.8 → 6.1.0

package/lib/detect-build-system.d.ts

@@ -0,0 +1,5 @@
+export declare type BuildSystem = {
+    name: string;
+    version?: string | undefined;
+};
+export declare const detectBuildSystems: (baseDir: string, rootDir?: string) => Promise<BuildSystem[]>;

package/lib/detect-build-system.js

@@ -0,0 +1,129 @@
+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 Promise.resolve({
+                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 Promise.resolve({
+                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 Promise.resolve({
+                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 Promise.resolve({
+                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 Promise.resolve({
+                name: 'lage',
+                version: devDependencies?.lage,
+            });
+        }
+    },
+    pants: async (baseDir, rootDir) => {
+        const pants = ['pants.toml'];
+        const pantsConfigPath = lookFor(pants, baseDir, rootDir);
+        if (pantsConfigPath) {
+            return Promise.resolve({
+                name: 'pants',
+            });
+        }
+    },
+    buck: async (baseDir, rootDir) => {
+        const buck = ['.buckconfig', 'BUCK'];
+        const buckConfigPath = lookFor(buck, baseDir, rootDir);
+        if (buckConfigPath) {
+            return Promise.resolve({
+                name: 'buck',
+            });
+        }
+    },
+    gradle: async (baseDir, rootDir) => {
+        const gradle = ['build.gradle'];
+        const gradleConfigPath = lookFor(gradle, baseDir, rootDir);
+        if (gradleConfigPath) {
+            return Promise.resolve({
+                name: 'gradle',
+            });
+        }
+    },
+    bazel: async (baseDir, rootDir) => {
+        const bazel = ['.bazelrc', 'WORKSPACE', 'WORKSPACE.bazel', 'BUILD.bazel'];
+        const bazelConfigPath = lookFor(bazel, baseDir, rootDir);
+        if (bazelConfigPath) {
+            return Promise.resolve({
+                name: 'bazel',
+            });
+        }
+    },
+    moon: async (baseDir, rootDir) => {
+        const moon = ['.moon'];
+        const moonConfigPath = lookFor(moon, baseDir, rootDir, 'directory');
+        if (moonConfigPath) {
+            const pkgJson = getPkgJson(moonConfigPath);
+            const { devDependencies } = pkgJson;
+            return Promise.resolve({
+                name: 'moon',
+                version: devDependencies?.moon,
+            });
+        }
+    },
+};
+const lookFor = (configFile, baseDir, rootDir, type) => {
+    return findUpSync(configFile, { cwd: baseDir, stopAt: rootDir, type: type });
+};
+const getPkgJson = (configPath) => {
+    return JSON.parse(readFileSync(path.join(path.dirname(configPath), 'package.json'), 'utf-8'));
+};

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

@@ -1,9 +1,11 @@
 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 declare 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,20 +1,23 @@
 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 = [];
+    let buildSystems = [];
     try {
-        // if the framework detection is crashing we should not crash the build info and package-manager
+        // if the framework or buildSystem detection is crashing we should not crash the build info and package-manager
         // detection
         frameworks = await listFrameworks({ projectDir: context.projectDir });
+        buildSystems = await detectBuildSystems(context.projectDir, context.rootDir);
     }
     catch {
         // TODO: build reporting to buildbot see: https://github.com/netlify/pillar-workflow/issues/1001
         // noop
     }
-    const info = { frameworks };
+    const info = { frameworks, buildSystems };
     // 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build-info",
-  "version": "6.0.8",
+  "version": "6.1.0",
   "description": "Build info utility",
   "type": "module",
   "exports": {
@@ -52,5 +52,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "b33663b6af4bd9acb552af1d17673679acb2ef75"
+  "gitHead": "e22d6106d734d2b4b7b49d2a2350be21913c0cbf"
 }