@netlify/build-info 6.2.2 → 6.2.3-rc.1

package/lib/{detect-package-manager.d.ts → src/package-managers/detect-package-manager.d.ts}

@@ -1,3 +1,4 @@
+import type { Project } from '../project.js';
 export declare const enum PkgManager {
     YARN = "yarn",
     PNPM = "pnpm",
@@ -8,6 +9,8 @@ export type PkgManagerFields = {
     name: PkgManager;
     /** The package managers install command */
     installCommand: string;
+    /** The package managers run command prefix */
+    runCommand: 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 */
@@ -22,8 +25,5 @@ export type PkgManagerFields = {
  * 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>;
+export declare const detectPackageManager: (project: Project) => Promise<PkgManagerFields | null>;

package/lib/src/package-managers/detect-package-manager.js

@@ -0,0 +1,82 @@
+/** The definition of all available package managers */
+const AVAILABLE_PACKAGE_MANAGERS = {
+    ["yarn" /* PkgManager.YARN */]: {
+        name: "yarn" /* PkgManager.YARN */,
+        installCommand: 'yarn install',
+        runCommand: 'yarn',
+        lockFile: 'yarn.lock',
+        forceEnvironment: 'NETLIFY_USE_YARN',
+    },
+    ["pnpm" /* PkgManager.PNPM */]: {
+        name: "pnpm" /* PkgManager.PNPM */,
+        installCommand: 'pnpm install',
+        runCommand: 'pnpm run',
+        lockFile: 'pnpm-lock.yaml',
+        forceEnvironment: 'NETLIFY_USE_PNPM',
+    },
+    ["npm" /* PkgManager.NPM */]: {
+        name: "npm" /* PkgManager.NPM */,
+        installCommand: 'npm install',
+        runCommand: 'npm run',
+        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
+ */
+export const detectPackageManager = async (project) => {
+    try {
+        const pkgPaths = await project.fs.findUpMultiple('package.json', {
+            cwd: project.baseDirectory,
+            stopAt: project.root,
+        });
+        // if there is no package json than there is no package manager to detect
+        if (!pkgPaths.length) {
+            return null;
+        }
+        for (const pkgPath of pkgPaths) {
+            const { packageManager } = await project.fs.readJSON(pkgPath);
+            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 && project.getEnv(pkgManager.forceEnvironment) === 'true') {
+                return pkgManager;
+            }
+        }
+        // find the correct lock file the tree up
+        const lockFilePath = await project.fs.findUp(Object.keys(lockFileMap), {
+            cwd: project.baseDirectory,
+            stopAt: project.root,
+        });
+        // 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 = project.fs.basename(lockFilePath);
+            const pkgManager = lockFileMap[lockFile];
+            // check if it not got disabled
+            if (!(pkgManager.forceEnvironment && project.getEnv(pkgManager.forceEnvironment) === 'false')) {
+                return pkgManager;
+            }
+        }
+    }
+    catch {
+        // noop
+    }
+    // always default to npm
+    // TODO: add some reporting here to log that we fall backed
+    return AVAILABLE_PACKAGE_MANAGERS["npm" /* PkgManager.NPM */];
+};

package/lib/src/project.d.ts

@@ -0,0 +1,53 @@
+import type { PackageJson } from 'read-pkg';
+import { SemVer } from 'semver';
+import type { BuildSystem } from './build-systems/build-system.js';
+import type { FileSystem } from './file-system.js';
+import { Framework } from './frameworks/framework.js';
+import type { PkgManagerFields } from './package-managers/detect-package-manager.js';
+import { WorkspaceInfo } from './workspaces/detect-workspace.js';
+/**
+ * The Project represents a Site in Netlify
+ * The only configuration here needed is the path to the repository root and the optional baseDirectory
+ */
+export declare class Project {
+    #private;
+    fs: FileSystem;
+    /** An optional repository root that tells us where to stop looking up */
+    root?: string;
+    /** An absolute path  */
+    baseDirectory: string;
+    /** the detected package manager (if null it's not a javascript project, undefined indicates that id did not run yet) */
+    packageManager: PkgManagerFields | null;
+    /** an absolute path of the root directory for js workspaces where the most top package.json is located */
+    jsWorkspaceRoot: string;
+    workspace: WorkspaceInfo | null;
+    /** The detected build-systems */
+    buildSystems: BuildSystem[];
+    /** The detected frameworks for each path in a project */
+    frameworks: Map<string, Framework[]>;
+    /** The current nodeVersion (can be set by node.js environments) */
+    private _nodeVersion;
+    setNodeVersion(version: string): this;
+    getCurrentNodeVersion(): Promise<SemVer | null>;
+    constructor(fs: FileSystem, baseDirectory?: string, root?: string);
+    /** Set's the environment for the project */
+    setEnvironment(env: Record<string, string | undefined>): this;
+    /** retrieves an environment variable */
+    getEnv(key: string): string | undefined;
+    /** retrieves the root package.json file */
+    getRootPackageJSON(): Promise<PackageJson>;
+    /** Retrieves the package.json and if one found with it's pkgPath */
+    getPackageJSON(startDirectory?: string): Promise<PackageJson & {
+        pkgPath: string | null;
+    }>;
+    /** Detects the used package Manager */
+    detectPackageManager(): Promise<PkgManagerFields | null>;
+    /** Detects the javascript workspace settings */
+    detectWorkspaces(): Promise<WorkspaceInfo | null>;
+    /** Detects all used build systems */
+    detectBuildSystem(): Promise<any[]>;
+    /** Detects all used build systems */
+    detectFrameworks(): Promise<Framework[] | null>;
+    private detectFrameworksInPath;
+    getDevServerSettings(): Promise<void>;
+}

package/lib/src/project.js

@@ -0,0 +1,207 @@
+import { parse, coerce } from 'semver';
+import { buildSystems } from './build-systems/index.js';
+import { frameworks } from './frameworks/index.js';
+import { detectPackageManager } from './package-managers/detect-package-manager.js';
+import { detectWorkspaces } from './workspaces/detect-workspace.js';
+/**
+ * The Project represents a Site in Netlify
+ * The only configuration here needed is the path to the repository root and the optional baseDirectory
+ */
+export class Project {
+    fs;
+    /** An optional repository root that tells us where to stop looking up */
+    root;
+    /** An absolute path  */
+    baseDirectory;
+    /** the detected package manager (if null it's not a javascript project, undefined indicates that id did not run yet) */
+    packageManager;
+    /** an absolute path of the root directory for js workspaces where the most top package.json is located */
+    jsWorkspaceRoot;
+    /* the detected javascript workspace information (if null it's not a workspace, undefined indicates that id did not run yet) */
+    workspace;
+    /** The detected build-systems */
+    buildSystems;
+    /** The detected frameworks for each path in a project */
+    frameworks;
+    /** a representation of the current environment */
+    #environment = {};
+    /** The current nodeVersion (can be set by node.js environments) */
+    _nodeVersion = null;
+    setNodeVersion(version) {
+        this._nodeVersion = parse(version);
+        return this;
+    }
+    async getCurrentNodeVersion() {
+        if (this._nodeVersion) {
+            return this._nodeVersion;
+        }
+        const nodeEnv = parse(coerce(this.getEnv('NODE_VERSION')), {
+            loose: true,
+        });
+        if (nodeEnv) {
+            return nodeEnv;
+        }
+        // TODO: parse .nvm file as well
+        return null;
+    }
+    constructor(fs, baseDirectory, root) {
+        this.fs = fs;
+        this.baseDirectory = fs.resolve(root || '', baseDirectory !== undefined ? baseDirectory : fs.cwd);
+        this.root = root ? fs.resolve(fs.cwd, root) : undefined;
+        // if the root and the base directory are the same unset the root again as its not a workspace
+        if (this.root === this.baseDirectory) {
+            this.root = undefined;
+        }
+        this.fs.cwd = this.baseDirectory;
+    }
+    /** Set's the environment for the project */
+    setEnvironment(env) {
+        this.#environment = env;
+        return this;
+    }
+    /** retrieves an environment variable */
+    getEnv(key) {
+        return this.#environment[key];
+    }
+    /** retrieves the root package.json file */
+    async getRootPackageJSON() {
+        // get the most upper json file
+        const rootJSONPath = (await this.fs.findUpMultiple('package.json', { cwd: this.baseDirectory, stopAt: this.root })).pop();
+        if (rootJSONPath) {
+            this.jsWorkspaceRoot = this.fs.dirname(rootJSONPath);
+            return this.fs.readJSON(rootJSONPath);
+        }
+        return {};
+    }
+    /** Retrieves the package.json and if one found with it's pkgPath */
+    async getPackageJSON(startDirectory) {
+        const pkgPath = await this.fs.findUp('package.json', {
+            cwd: startDirectory || this.baseDirectory,
+            stopAt: this.root,
+        });
+        if (pkgPath) {
+            const json = await this.fs.readJSON(pkgPath);
+            return {
+                ...json,
+                pkgPath,
+            };
+        }
+        return { pkgPath: null };
+    }
+    /** Detects the used package Manager */
+    async detectPackageManager() {
+        // if the packageManager is undefined, the detection was not run.
+        // if it is an object or null it has already run
+        if (this.packageManager !== undefined) {
+            return this.packageManager;
+        }
+        try {
+            this.packageManager = await detectPackageManager(this);
+            return this.packageManager;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Detects the javascript workspace settings */
+    async detectWorkspaces() {
+        // if the workspace is undefined, the detection was not run.
+        // if it is an object or null it has already run
+        if (this.workspace !== undefined) {
+            return this.workspace;
+        }
+        // workspaces depend on package manager detection so run it first
+        await this.detectPackageManager();
+        try {
+            this.workspace = await detectWorkspaces(this);
+            return this.workspace;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Detects all used build systems */
+    async detectBuildSystem() {
+        // if the workspace is undefined, the detection was not run.
+        if (this.buildSystems !== undefined) {
+            return this.buildSystems;
+        }
+        // build systems depends on workspaces detection
+        await this.detectWorkspaces();
+        try {
+            const detected = [];
+            // perform the detection in series to avoid having the same HTTP request in parallel.
+            // It's faster to perform one detection, do all the needed HTTP requests and reuse the results
+            // on consecutive runs.
+            for (const BuildSystem of buildSystems) {
+                const res = await new BuildSystem(this).detect();
+                if (res) {
+                    detected.push(res.toJSON());
+                }
+            }
+            return detected;
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Detects all used build systems */
+    async detectFrameworks() {
+        // if the workspace is undefined, the detection was not run.
+        if (this.frameworks !== undefined) {
+            return [...this.frameworks.values()].flat();
+        }
+        try {
+            // This needs to be run first
+            await this.detectBuildSystem();
+            this.frameworks = new Map();
+            if (this.workspace?.isRoot) {
+                for (const pkg of this.workspace.packages) {
+                    this.frameworks.set(pkg, await this.detectFrameworksInPath(pkg));
+                }
+            }
+            else {
+                this.frameworks.set('', await this.detectFrameworksInPath());
+            }
+            return [...this.frameworks.values()].flat();
+        }
+        catch {
+            return null;
+        }
+    }
+    async detectFrameworksInPath(path) {
+        try {
+            const detected = [];
+            // perform the detection in series to avoid having the same HTTP request in parallel.
+            // It's faster to perform one detection, do all the needed HTTP requests and reuse the results
+            // on consecutive runs.
+            for (const Frameowk of frameworks) {
+                const res = await new Frameowk(this, path).detect();
+                if (res) {
+                    detected.push(res);
+                }
+            }
+            return detected;
+        }
+        catch {
+            return [];
+        }
+    }
+    async getDevServerSettings() {
+        await this.detectFrameworks();
+        const buildSystem = this.buildSystems.find((system) => system.dev);
+        if (buildSystem) {
+            console.log(buildSystem);
+            // get the framework for the default build system
+            // if (this.frameworks.size > 1) {
+            // }
+            // console.log(this.frameworks)
+        }
+        // TODO return frameworks
+        // console.log(this)
+        // return {
+        //   command: '',
+        //   frameworkPort: number,
+        // }
+    }
+}

package/lib/src/workspaces/detect-workspace.d.ts

@@ -0,0 +1,22 @@
+import type { PackageJson } from 'read-pkg';
+import { Project } from '../project.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 function detectPnpmWorkspaceGlobs(project: Project): Promise<string[]>;
+/** Get the workspace globs from the package.json file */
+export declare function detectNpmOrYarnWorkspaceGlobs(pkgJSON: PackageJson): Promise<string[]>;
+/**
+ * If it's a javascript workspace (npm, pnpm, yarn) it will retrieve a list of all
+ * package paths and will indicate if it's the root of the workspace
+ */
+export declare function detectWorkspaces(project: Project): Promise<WorkspaceInfo | null>;

package/lib/src/workspaces/detect-workspace.js

@@ -0,0 +1,61 @@
+import { parse } from 'yaml';
+import { getWorkspacePackages } from './get-workspace-packages.js';
+/**
+ * Get a list of globs about all the packages inside a pnpm workspace
+ * https://pnpm.io/pnpm-workspace_yaml
+ */
+export async function detectPnpmWorkspaceGlobs(project) {
+    const workspaceFile = await project.fs.findUp('pnpm-workspace.yaml', {
+        cwd: project.baseDirectory,
+        stopAt: project.root,
+    });
+    if (!workspaceFile) {
+        return [];
+    }
+    try {
+        const { packages } = parse(await project.fs.readFile(workspaceFile));
+        return packages;
+    }
+    catch {
+        return [];
+    }
+}
+/** Get the workspace globs from the package.json file */
+export async function 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
+ * package paths and will indicate if it's the root of the workspace
+ */
+export async function detectWorkspaces(project) {
+    if (!project.packageManager) {
+        throw new Error('Please run the packageManager detection before calling the workspace detection!');
+    }
+    const pkgJSON = await project.getRootPackageJSON();
+    const workspaceGlobs = project.packageManager.name === "pnpm" /* PkgManager.PNPM */
+        ? await detectPnpmWorkspaceGlobs(project)
+        : await detectNpmOrYarnWorkspaceGlobs(pkgJSON);
+    if (workspaceGlobs.length === 0) {
+        return null;
+    }
+    const packages = await getWorkspacePackages(project, workspaceGlobs);
+    const isRoot = project.baseDirectory === project.jsWorkspaceRoot;
+    const relBaseDirectory = project.fs.relative(project.jsWorkspaceRoot, project.baseDirectory);
+    // if the current base directory is not part of the detected workspace packages it's not part of this workspace
+    // and therefore return no workspace info
+    if (!isRoot && !packages.includes(relBaseDirectory)) {
+        return null;
+    }
+    return {
+        rootDir: project.jsWorkspaceRoot,
+        isRoot,
+        packages,
+    };
+}

package/lib/src/workspaces/get-workspace-packages.d.ts

@@ -0,0 +1,20 @@
+import { DirType } from '../file-system.js';
+import type { Project } from '../project.js';
+export type identifyPackageFn = (options: {
+    entry: string;
+    type: DirType;
+    directory: string;
+}) => Promise<boolean> | boolean;
+/** Find all packages inside a provided directory */
+export declare function findPackages(project: Project, 
+/**
+ * The relative directory it should start checking.
+ * If a jsWorkspaceRoot is set it will join it with it otherwise it tries to resolve based on the root
+ */
+dir: string, 
+/** A function that identifies if a directory is a package. By default it checks if it has a package.json */
+identifyPackage: identifyPackageFn, 
+/** The depth to look. It can be either a single star `*` for one directory depth or a `**` for deep checking */
+depth?: string): Promise<string[]>;
+/** Get a list of all workspace package paths (absolute paths) */
+export declare function getWorkspacePackages(project: Project, patterns: string[]): Promise<string[]>;

package/lib/src/workspaces/get-workspace-packages.js

@@ -0,0 +1,80 @@
+import minimatch, { Minimatch } from 'minimatch';
+/** Get the base directory out of a glob pattern */
+function getDirFromPattern(pattern) {
+    const dir = [];
+    const parts = pattern.globParts[0];
+    for (let i = 0, max = parts.length; i < max; i++) {
+        if (parts[i].includes('*')) {
+            // skip the rest
+            return { dir: dir.join('/'), depth: parts[i] };
+        }
+        dir.push(parts[i]);
+    }
+    return { dir: dir.join('/') };
+}
+const defaultIdentifyPackage = ({ entry }) => entry === 'package.json';
+/** Find all packages inside a provided directory */
+export async function findPackages(project, 
+/**
+ * The relative directory it should start checking.
+ * If a jsWorkspaceRoot is set it will join it with it otherwise it tries to resolve based on the root
+ */
+dir, 
+/** A function that identifies if a directory is a package. By default it checks if it has a package.json */
+identifyPackage, 
+/** The depth to look. It can be either a single star `*` for one directory depth or a `**` for deep checking */
+depth) {
+    const found = [];
+    let content = {};
+    const startDir = project.jsWorkspaceRoot
+        ? project.fs.resolve(project.jsWorkspaceRoot, dir)
+        : project.root
+            ? project.fs.resolve(project.root, dir)
+            : project.fs.resolve(dir);
+    try {
+        content = await project.fs.readDir(startDir, true);
+    }
+    catch (err) {
+        // noop
+    }
+    for (const [part, type] of Object.entries(content)) {
+        if (await identifyPackage({ entry: part, type, directory: startDir })) {
+            found.push(dir);
+        }
+        if (depth && type === 'directory') {
+            found.push(...(await findPackages(project, project.fs.join(dir, part), identifyPackage, depth === '**' ? depth : undefined)));
+        }
+    }
+    return found;
+}
+/** Get a list of all workspace package paths (absolute paths) */
+export async function getWorkspacePackages(project, patterns) {
+    const results = [];
+    if (!patterns.length) {
+        return results;
+    }
+    for (const pattern of patterns) {
+        const matcher = new Minimatch(pattern);
+        // skip negated pattern for exploring as we filter at the end
+        if (matcher.negate) {
+            continue;
+        }
+        const { dir, depth } = getDirFromPattern(matcher);
+        results.push(...(await findPackages(project, dir, defaultIdentifyPackage, depth)));
+    }
+    // initially add all results to the set
+    // and filter out then the negated patterns
+    const filtered = new Set();
+    for (const result of results) {
+        for (const pattern of patterns) {
+            const matcher = new Minimatch(pattern);
+            if (minimatch(result, matcher.pattern)) {
+                filtered.add(project.fs.join(result));
+                if (matcher.negate) {
+                    filtered.delete(project.fs.join(result));
+                }
+            }
+        }
+    }
+    return [...filtered];
+}