@netlify/build-info 6.0.6 → 6.0.8-rc

package/lib/context.js

@@ -29,7 +29,14 @@ export const getContext = async (config = {}) => {
     // If rootDir equals projectDir we'll be getting the projectDir package.json
     // Later on if we also need the projectDir package.json we can check for it
     // and only perform one resolution
-    const rootPackageJson = await getRootPackageJson(absoluteProjectDir, validRootDir || absoluteProjectDir);
+    let rootPackageJson = {};
+    try {
+        rootPackageJson = await getRootPackageJson(absoluteProjectDir, validRootDir || absoluteProjectDir);
+    }
+    catch {
+        // gracefully handle un-parseable package.json files
+        //noop
+    }
     return {
         projectDir: absoluteProjectDir,
         rootDir: validRootDir,

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,117 @@
+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'];
+        const bazelConfigPath = lookFor(bazel, baseDir, rootDir);
+        if (bazelConfigPath) {
+            return Promise.resolve({
+                name: 'bazel',
+            });
+        }
+    },
+};
+const lookFor = (configFile, baseDir, rootDir) => {
+    return findUpSync(configFile, { cwd: baseDir, stopAt: rootDir });
+};
+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,12 +1,21 @@
 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);
-    const info = {
-        frameworks: await listFrameworks({ projectDir: context.projectDir }),
-    };
+    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 };
     // 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);
@@ -15,5 +24,9 @@ export const getBuildInfo = async (opts) => {
             info.jsWorkspaces = workspaceInfo;
         }
     }
+    const buildSystems = await detectBuildSystems(context.projectDir, context.rootDir);
+    if (buildSystems.length > 0) {
+        info.buildSystems = buildSystems;
+    }
     return info;
 };

package/package.json

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