@netlify/build-info 5.2.0-framework-version-detection → 6.0.0

package/lib/bin.d.ts

@@ -1,2 +1 @@
-#!/usr/bin/env node
 export {};

package/lib/bin.js

@@ -1,26 +1,22 @@
-#!/usr/bin/env node
 import { exit, argv } from 'process';
+import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import yargs from 'yargs/yargs';
-import { getBuildInfo } from './main.js';
-const { projectDir, rootDir } = yargs(hideBin(argv))
-    .command('* [projectDir]')
-    .options({
+import { getBuildInfo } from './get-build-info.js';
+yargs(hideBin(argv))
+    .command('* [projectDir]', 'Print relevant build information from a project.', (builder) => builder.options({
     rootDir: {
         string: true,
         describe: `The root directory of the project if different from projectDir`,
     },
+}), async ({ projectDir, rootDir }) => {
+    try {
+        const buildInfo = await getBuildInfo({ projectDir, rootDir });
+        console.log(JSON.stringify(buildInfo, null, 2));
+    }
+    catch (error) {
+        console.error(error);
+        exit(1);
+    }
 })
-    .usage(`$0 [OPTIONS...] [PROJECT_DIRECTORY]
-
-  Print relevant build information from a project.`)
     .strict()
     .parse();
-try {
-    const buildInfo = await getBuildInfo({ projectDir, rootDir });
-    console.log(JSON.stringify(buildInfo, null, 2));
-}
-catch (error) {
-    console.error(error);
-    exit(1);
-}

package/lib/context.d.ts

@@ -5,7 +5,7 @@ export declare type ContextOptions = {
 };
 export declare type Context = {
     projectDir: string;
-    rootDir: string;
+    rootDir?: string;
     rootPackageJson: PackageJson;
 };
 export declare const getContext: (config?: ContextOptions) => Promise<Context>;

package/lib/detect-package-manager.d.ts

@@ -0,0 +1,29 @@
+export declare const enum PkgManager {
+    YARN = "yarn",
+    PNPM = "pnpm",
+    NPM = "npm"
+}
+export declare type PkgManagerFields = {
+    /** The package managers name that is used for logging */
+    name: PkgManager;
+    /** The package managers install command */
+    installCommand: string;
+    /** The lock file a package manager is using */
+    lockFile: string;
+    /** Environment variable that can be used to force the usage of a package manager even though there is no lock file or a different lock file */
+    forceEnvironment?: string;
+    /** Flags that should be used for running the install command */
+    installFlags?: string[];
+    /** A list of all cache locations for the package manager */
+    cacheLocations?: string[];
+};
+/**
+ * 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 declare const detectPackageManager: (cwd?: string, stopAt?: string) => Promise<PkgManagerFields>;

package/lib/detect-package-manager.js

@@ -0,0 +1,71 @@
+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

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

package/lib/get-build-info.js

@@ -0,0 +1,19 @@
+import { listFrameworks } from '@netlify/framework-info';
+import { getContext } from './context.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 }),
+    };
+    // 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/index.d.ts

@@ -0,0 +1 @@
+export { getBuildInfo } from './get-build-info.js';

package/lib/index.js

@@ -0,0 +1 @@
+export { getBuildInfo } from './get-build-info.js';

package/lib/workspaces.d.ts

@@ -1,5 +1,22 @@
+import { PackageJson } from 'read-pkg';
 import type { Context } from './context.js';
-export declare const getWorkspaceInfo: (context: Context) => Promise<{
+import { PkgManagerFields } from './detect-package-manager.js';
+export declare type WorkspaceInfo = {
+    /** if we are in the current workspace root or not */
     isRoot: boolean;
-    packages: any[];
-}>;
+    /** 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,18 +1,56 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, relative } from 'path';
 import mapWorkspaces from '@npmcli/map-workspaces';
-export const getWorkspaceInfo = async (context) => {
-    if (!context.rootPackageJson.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: context.rootDir || context.projectDir,
-        pkg: context.rootPackageJson,
+        cwd: rootDir,
+        pkg: { workspaces: workspaceGlobs },
     });
-    const packages = [...workspacesMap.values()];
-    // The provided project dir is a workspace package
-    const isWorkspace = packages.find((path) => context.projectDir === path);
+    // 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 };
+        return {
+            isRoot,
+            packages,
+            rootDir,
+        };
     }
 };

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@netlify/build-info",
-  "version": "5.2.0-framework-version-detection",
+  "version": "6.0.0",
   "description": "Build info utility",
   "type": "module",
-  "exports": "./lib/main.js",
-  "main": "./lib/main.js",
-  "types": "./lib/main.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
   "bin": {
     "build-info": "./bin.js"
   },
@@ -17,7 +19,7 @@
     "prebuild": "rm -rf lib",
     "build": "tsc",
     "test": "vitest run",
-    "test:dev": "vitest",
+    "test:dev": "vitest --ui",
     "test:ci": "vitest run --reporter=default"
   },
   "keywords": [],
@@ -28,19 +30,27 @@
   },
   "author": "Netlify Inc.",
   "dependencies": {
-    "@netlify/framework-info": "9.3.1-framework-version-detection.0",
+    "@netlify/framework-info": "^9.3.0",
     "@npmcli/map-workspaces": "^2.0.0",
-    "read-pkg": "^7.0.0",
-    "yargs": "^17.0.0"
+    "find-up": "^6.3.0",
+    "read-pkg": "^7.1.0",
+    "yargs": "^17.6.0"
   },
   "devDependencies": {
     "@types/node": "^14.18.31",
+    "@types/semver": "^7.3.13",
     "@vitest/coverage-c8": "^0.24.1",
+    "@vitest/ui": "^0.24.3",
     "execa": "^6.0.0",
+    "memfs": "^3.4.7",
+    "semver": "^7.3.8",
     "typescript": "^4.8.4",
-    "vitest": "^0.24.1"
+    "unionfs": "^4.4.0",
+    "vitest": "^0.24.1",
+    "yaml": "^2.1.3"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
-  }
+  },
+  "gitHead": "8e802afa869a43b3248e0fd3b25fb9a06a416072"
 }

package/lib/core.d.ts

@@ -1,11 +0,0 @@
-import type { Context } from './context.js';
-export declare const buildInfo: (context: Context) => Promise<{
-    frameworks: any;
-    jsWorkspaces: {
-        isRoot: boolean;
-        packages: any[];
-    };
-} | {
-    frameworks: any;
-    jsWorkspaces?: undefined;
-}>;

package/lib/core.js

@@ -1,8 +0,0 @@
-import { listFrameworks } from '@netlify/framework-info';
-import { getWorkspaceInfo } from './workspaces.js';
-export const buildInfo = async function (context) {
-    const workspaceInfo = await getWorkspaceInfo(context);
-    const jsWorkspaces = workspaceInfo ? { jsWorkspaces: workspaceInfo } : {};
-    const frameworks = await listFrameworks({ projectDir: context.projectDir });
-    return { ...jsWorkspaces, frameworks };
-};

package/lib/main.d.ts

@@ -1,11 +0,0 @@
-import { ContextOptions } from './context.js';
-export declare const getBuildInfo: (opts: ContextOptions) => Promise<{
-    frameworks: any;
-    jsWorkspaces: {
-        isRoot: boolean;
-        packages: any[];
-    };
-} | {
-    frameworks: any;
-    jsWorkspaces?: undefined;
-}>;

package/lib/main.js

@@ -1,6 +0,0 @@
-import { getContext } from './context.js';
-import { buildInfo } from './core.js';
-export const getBuildInfo = async (opts) => {
-    const context = await getContext(opts);
-    return await buildInfo(context);
-};