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

package/bin.js

@@ -2,4 +2,4 @@
 
 // This is a workaround for npm issue: https://github.com/npm/cli/issues/2632
 
-import './lib/bin.js'
+import './lib/src/node/bin.js'

package/lib/src/browser/file-system.d.ts

@@ -0,0 +1,25 @@
+import { DirType, FileSystem } from '../file-system.js';
+/** A sample implementation of a github provider */
+export declare class GithubProvider {
+    repo: string;
+    branch?: string | undefined;
+    constructor(repo: string, branch?: string | undefined);
+    dir(filePath?: string): Promise<{
+        path: string;
+        type: 'file' | 'dir';
+    }[]>;
+    read(filePath: string): Promise<string>;
+    private request;
+}
+/** A sample implementation of a web based file system that fetches from Github */
+export declare class WebFS extends FileSystem {
+    git: GithubProvider;
+    constructor(git: GithubProvider);
+    isAbsolute(path: string): boolean;
+    resolve(...paths: string[]): string;
+    fileExists(path: string): Promise<boolean>;
+    /** Get a list of directory entries */
+    readDir(path: string): Promise<string[]>;
+    readDir(path: string, withFileTypes: true): Promise<Record<string, DirType>>;
+    readFile(path: string): Promise<string>;
+}

package/lib/src/browser/file-system.js

@@ -0,0 +1,70 @@
+import { FileSystem } from '../file-system.js';
+/** A sample implementation of a github provider */
+export class GithubProvider {
+    repo;
+    branch;
+    constructor(repo, branch) {
+        this.repo = repo;
+        this.branch = branch;
+    }
+    async dir(filePath = '') {
+        let path = `/repos/${this.repo}/contents${filePath}`;
+        if (this.branch) {
+            path += `?ref=${this.branch}`;
+        }
+        return this.request(path);
+    }
+    async read(filePath) {
+        const headers = { Accept: 'application/vnd.github.VERSION.raw' };
+        let path = `/repos/${this.repo}/contents${filePath}`;
+        if (this.branch) {
+            path += `?ref=${this.branch}`;
+        }
+        return this.request(path, headers);
+    }
+    async request(path, headers = {}) {
+        const response = await fetch(new URL(path, `https://api.github.com`).href, { headers });
+        if (response.headers?.get('Content-Type')?.match(/json/)) {
+            const json = await response.json();
+            if (!response.ok) {
+                Promise.reject(json);
+            }
+            return json;
+        }
+        return response.text();
+    }
+}
+/** A sample implementation of a web based file system that fetches from Github */
+export class WebFS extends FileSystem {
+    git;
+    constructor(git) {
+        super();
+        this.git = git;
+    }
+    isAbsolute(path) {
+        return path.startsWith('/');
+    }
+    resolve(...paths) {
+        const path = this.join(...paths);
+        return this.isAbsolute(path) ? path : this.join(this.cwd, path);
+    }
+    async fileExists(path) {
+        try {
+            this.readFile(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async readDir(path, withFileTypes) {
+        const result = await this.git.dir(this.resolve(path));
+        if (!withFileTypes) {
+            return result.map(({ path }) => path);
+        }
+        return result.reduce((prev, cur) => ({ ...prev, [cur.path]: cur.type === 'dir' ? 'directory' : 'file' }), {});
+    }
+    async readFile(path) {
+        return this.git.read(this.resolve(path));
+    }
+}

package/lib/src/build-systems/bazel.d.ts

@@ -0,0 +1,7 @@
+import { BaseBuildTool } from './build-system.js';
+export declare class Bazel extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+    detect(): Promise<this | undefined>;
+}

package/lib/src/build-systems/bazel.js

@@ -0,0 +1,15 @@
+import { BaseBuildTool } from './build-system.js';
+export class Bazel extends BaseBuildTool {
+    id = 'bazel';
+    name = 'Bazel';
+    configFiles = ['.bazelrc', 'WORKSPACE', 'WORKSPACE.bazel', 'BUILD.bazel'];
+    async detect() {
+        const config = await this.project.fs.findUp(this.configFiles, {
+            cwd: this.project.baseDirectory,
+            stopAt: this.project.root,
+        });
+        if (config) {
+            return this;
+        }
+    }
+}

package/lib/src/build-systems/buck.d.ts

@@ -0,0 +1,7 @@
+import { BaseBuildTool } from './build-system.js';
+export declare class Buck extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+    detect(): Promise<this | undefined>;
+}

package/lib/src/build-systems/buck.js

@@ -0,0 +1,15 @@
+import { BaseBuildTool } from './build-system.js';
+export class Buck extends BaseBuildTool {
+    id = 'buck';
+    name = 'Buck';
+    configFiles = ['.buckconfig', 'BUCK'];
+    async detect() {
+        const config = await this.project.fs.findUp(this.configFiles, {
+            cwd: this.project.baseDirectory,
+            stopAt: this.project.root,
+        });
+        if (config) {
+            return this;
+        }
+    }
+}

package/lib/src/build-systems/build-system.d.ts

@@ -0,0 +1,29 @@
+import { PollingStrategy } from '../frameworks/framework.js';
+import { Project } from '../project.js';
+export interface BuildSystem {
+    id: string;
+    name: string;
+    project: Project;
+    version?: string;
+    dev?: {
+        command: string;
+        port?: number;
+        pollingStrategies?: PollingStrategy[];
+    };
+    detect(): Promise<BuildSystem | undefined>;
+}
+export declare abstract class BaseBuildTool implements BuildSystem {
+    project: Project;
+    id: string;
+    name: string;
+    version?: string;
+    configFiles: string[];
+    constructor(project: Project);
+    detect(): Promise<this | undefined>;
+    /** Get's a JSON from the class information */
+    toJSON(): {
+        id: string;
+        name: string;
+        version: string | undefined;
+    };
+}

package/lib/src/build-systems/build-system.js

@@ -0,0 +1,25 @@
+export class BaseBuildTool {
+    project;
+    id;
+    name;
+    version;
+    configFiles = [];
+    constructor(project) {
+        this.project = project;
+    }
+    async detect() {
+        const config = await this.project.fs.findUp(this.configFiles, {
+            cwd: this.project.baseDirectory,
+            stopAt: this.project.root,
+        });
+        if (config) {
+            const pkgJson = await this.project.getPackageJSON(this.project.fs.dirname(config));
+            this.version = pkgJson.devDependencies?.[this.id];
+            return this;
+        }
+    }
+    /** Get's a JSON from the class information */
+    toJSON() {
+        return { id: this.id, name: this.name, version: this.version };
+    }
+}

package/lib/src/build-systems/gradle.d.ts

@@ -0,0 +1,7 @@
+import { BaseBuildTool } from './build-system.js';
+export declare class Gradle extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+    detect(): Promise<this | undefined>;
+}

package/lib/src/build-systems/gradle.js

@@ -0,0 +1,15 @@
+import { BaseBuildTool } from './build-system.js';
+export class Gradle extends BaseBuildTool {
+    id = 'gradle';
+    name = 'Gradle';
+    configFiles = ['build.gradle'];
+    async detect() {
+        const config = await this.project.fs.findUp(this.configFiles, {
+            cwd: this.project.baseDirectory,
+            stopAt: this.project.root,
+        });
+        if (config) {
+            return this;
+        }
+    }
+}

package/lib/src/build-systems/index.d.ts

@@ -0,0 +1,2 @@
+import { Bazel } from './bazel.js';
+export declare const buildSystems: (typeof Bazel)[];

package/lib/src/build-systems/index.js

@@ -0,0 +1,11 @@
+import { Bazel } from './bazel.js';
+import { Buck } from './buck.js';
+import { Gradle } from './gradle.js';
+import { Lage } from './lage.js';
+import { Moon } from './moon.js';
+import { Nix } from './nix.js';
+import { Lerna, Nx } from './nrwl.js';
+import { Pants } from './pants.js';
+import { Rush } from './rush.js';
+import { Turbo } from './turbo.js';
+export const buildSystems = [Bazel, Buck, Gradle, Lage, Lerna, Moon, Nix, Nx, Pants, Rush, Turbo];

package/lib/src/build-systems/lage.d.ts

@@ -0,0 +1,6 @@
+import { BaseBuildTool } from './build-system.js';
+export declare class Lage extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+}

package/lib/src/build-systems/lage.js

@@ -0,0 +1,6 @@
+import { BaseBuildTool } from './build-system.js';
+export class Lage extends BaseBuildTool {
+    id = 'lage';
+    name = 'Lage';
+    configFiles = ['lage.config.js'];
+}

package/lib/src/build-systems/moon.d.ts

@@ -0,0 +1,7 @@
+import { BaseBuildTool } from './build-system.js';
+export declare class Moon extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+    detect(): Promise<this | undefined>;
+}

package/lib/src/build-systems/moon.js

@@ -0,0 +1,18 @@
+import { BaseBuildTool } from './build-system.js';
+export class Moon extends BaseBuildTool {
+    id = 'moon';
+    name = 'MoonRepo';
+    configFiles = ['.moon'];
+    async detect() {
+        const config = await this.project.fs.findUp(this.configFiles, {
+            cwd: this.project.baseDirectory,
+            type: 'directory',
+            stopAt: this.project.root,
+        });
+        if (config) {
+            const pkgJson = await this.project.getPackageJSON(config);
+            this.version = pkgJson.devDependencies?.[this.id];
+            return this;
+        }
+    }
+}

package/lib/src/build-systems/nix.d.ts

@@ -0,0 +1,7 @@
+import { BaseBuildTool } from './build-system.js';
+export declare class Nix extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+    detect(): Promise<this | undefined>;
+}

package/lib/src/build-systems/nix.js

@@ -0,0 +1,15 @@
+import { BaseBuildTool } from './build-system.js';
+export class Nix extends BaseBuildTool {
+    id = 'nix';
+    name = 'Nix';
+    configFiles = ['default.nix', 'shell.nix', 'release.nix'];
+    async detect() {
+        const config = await this.project.fs.findUp(this.configFiles, {
+            cwd: this.project.baseDirectory,
+            stopAt: this.project.root,
+        });
+        if (config) {
+            return this;
+        }
+    }
+}

package/lib/src/build-systems/nrwl.d.ts

@@ -0,0 +1,16 @@
+import { BaseBuildTool } from './build-system.js';
+export declare class Nx extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+    dev: {
+        commands: string[];
+        port: number;
+    };
+    detect(): Promise<this | undefined>;
+}
+export declare class Lerna extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+}

package/lib/src/build-systems/nrwl.js

@@ -0,0 +1,55 @@
+import { findPackages } from '../workspaces/get-workspace-packages.js';
+import { BaseBuildTool } from './build-system.js';
+export class Nx extends BaseBuildTool {
+    id = 'nx';
+    name = 'Nx';
+    configFiles = ['nx.json'];
+    dev = {
+        commands: ['nx serve'],
+        port: 4200,
+    };
+    async detect() {
+        const detected = await super.detect();
+        const fs = this.project.fs;
+        if (detected) {
+            try {
+                // in nx integrated setup the workspace is not managed through the package manager
+                // in this case we have to check the `nx.json` for the project references
+                if (this.project.workspace === null) {
+                    const { workspaceLayout } = await fs.readJSON(fs.join(this.project.jsWorkspaceRoot, 'nx.json'));
+                    // if an apps dir is specified get it.
+                    if (workspaceLayout?.appsDir?.length) {
+                        const identifyPkg = async ({ entry, directory }) => {
+                            if (entry === 'project.json') {
+                                try {
+                                    // we need to check the project json for application types (we don't care about libraries)
+                                    const { projectType } = await fs.readJSON(fs.join(directory, entry));
+                                    return projectType === 'application';
+                                }
+                                catch {
+                                    return false;
+                                }
+                            }
+                            return false;
+                        };
+                        const packages = await findPackages(this.project, workspaceLayout.appsDir, identifyPkg, '*');
+                        this.project.workspace = {
+                            isRoot: this.project.jsWorkspaceRoot === this.project.baseDirectory,
+                            packages,
+                            rootDir: this.project.jsWorkspaceRoot,
+                        };
+                    }
+                }
+            }
+            catch {
+                // noop
+            }
+            return this;
+        }
+    }
+}
+export class Lerna extends BaseBuildTool {
+    id = 'lerna';
+    name = 'Lerna';
+    configFiles = ['lerna.json'];
+}

package/lib/src/build-systems/pants.d.ts

@@ -0,0 +1,7 @@
+import { BaseBuildTool } from './build-system.js';
+export declare class Pants extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+    detect(): Promise<this | undefined>;
+}

package/lib/src/build-systems/pants.js

@@ -0,0 +1,15 @@
+import { BaseBuildTool } from './build-system.js';
+export class Pants extends BaseBuildTool {
+    id = 'pants';
+    name = 'Pants';
+    configFiles = ['pants.toml'];
+    async detect() {
+        const config = await this.project.fs.findUp(this.configFiles, {
+            cwd: this.project.baseDirectory,
+            stopAt: this.project.root,
+        });
+        if (config) {
+            return this;
+        }
+    }
+}

package/lib/src/build-systems/rush.d.ts

@@ -0,0 +1,6 @@
+import { BaseBuildTool } from './build-system.js';
+export declare class Rush extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+}

package/lib/src/build-systems/rush.js

@@ -0,0 +1,6 @@
+import { BaseBuildTool } from './build-system.js';
+export class Rush extends BaseBuildTool {
+    id = 'rush';
+    name = 'Rush';
+    configFiles = ['rush.json'];
+}

package/lib/src/build-systems/turbo.d.ts

@@ -0,0 +1,6 @@
+import { BaseBuildTool } from './build-system.js';
+export declare class Turbo extends BaseBuildTool {
+    id: string;
+    name: string;
+    configFiles: string[];
+}

package/lib/src/build-systems/turbo.js

@@ -0,0 +1,6 @@
+import { BaseBuildTool } from './build-system.js';
+export class Turbo extends BaseBuildTool {
+    id = 'turbo';
+    name = 'TurboRepo';
+    configFiles = ['turbo.json'];
+}

package/lib/src/file-system.d.ts

@@ -0,0 +1,54 @@
+export interface Logger {
+    debug(...any: any[]): void;
+    log(...any: any[]): void;
+    error(...any: any[]): void;
+}
+export type DirType = 'directory' | 'file';
+export type TextFile = {
+    content: string;
+    type: 'text';
+};
+export type JSONFile<T = Record<string, any>> = {
+    content: T;
+    type: 'json';
+};
+export type TOMLFile = {
+    content: string;
+    type: 'toml';
+};
+export type File = TextFile | JSONFile | TOMLFile;
+export type findUpOptions = {
+    cwd?: string;
+    type?: DirType;
+    stopAt?: string;
+};
+/** A platform independent version of path.join() */
+export declare function join(...segments: string[]): string;
+export declare abstract class FileSystem {
+    logger: Logger;
+    /** The current working directory will be set by the project */
+    cwd: string;
+    abstract fileExists(path: string): Promise<boolean>;
+    abstract readDir(path: string): Promise<string[]>;
+    abstract readDir(path: string, withFileTypes: true): Promise<Record<string, DirType>>;
+    abstract readDir(path: string, withFileTypes?: true): Promise<Record<string, DirType> | string[]>;
+    abstract readFile(path: string): Promise<string>;
+    /** resolves a path to an absolute path */
+    abstract resolve(...paths: string[]): string;
+    /** check if a path is an absolute path */
+    abstract isAbsolute(path: string): boolean;
+    /** returns the last portion of a path */
+    basename(path: string): string;
+    /** returns the relative path from to based on the current working directory */
+    relative(from: string, to: string): string;
+    /** returns the directory name of a path */
+    dirname(path: string): string;
+    /** A platform independent version of path.join() */
+    join(...segments: string[]): string;
+    /** Gracefully reads a file as JSON and parses it */
+    readJSON<V = Record<string, unknown>>(path: string): Promise<Partial<V>>;
+    /** Find a file or directory by walking up parent directories. */
+    findUp(name: string | readonly string[], options?: findUpOptions): Promise<string | undefined>;
+    /** Find files or directories by walking up parent directories. */
+    findUpMultiple(name: string | readonly string[], options?: findUpOptions): Promise<string[]>;
+}

package/lib/src/file-system.js

@@ -0,0 +1,160 @@
+class DefaultLogger {
+    debug(...data) {
+        // TODO: add reporting
+        console.debug(...data);
+    }
+    log(...data) {
+        console.log(...data);
+    }
+    error(...data) {
+        // TODO: on error add reporting
+        console.error(...data);
+    }
+}
+/** A platform independent version of path.join() */
+export function join(...segments) {
+    let parts = [];
+    for (let i = 0, max = segments.length; i < max; i++) {
+        // split the segments to parts by all kind of separator (forward and backward)
+        parts = parts.concat(segments[i].split(/[\\/]/g));
+    }
+    // resolve .. inside path segments
+    const resolvedParts = [];
+    for (let i = 0, max = parts.length; i < max; i++) {
+        const part = parts[i];
+        // Remove leading and trailing slashes
+        // Also remove "." segments
+        if (!part || part === '.')
+            continue;
+        // Interpret ".." to pop the last segment
+        if (part === '..') {
+            resolvedParts.pop();
+        }
+        else {
+            resolvedParts.push(part);
+        }
+    }
+    // Preserve the initial slash if there was one.
+    if (parts[0] === '') {
+        resolvedParts.unshift('');
+    }
+    return resolvedParts.join('/') || (resolvedParts.length ? '/' : '.');
+}
+export class FileSystem {
+    logger = new DefaultLogger();
+    /** The current working directory will be set by the project */
+    cwd = '/';
+    /** returns the last portion of a path */
+    basename(path) {
+        return this.join(path).split('/').pop() || '';
+    }
+    /** returns the relative path from to based on the current working directory */
+    relative(from, to) {
+        const absoluteFrom = this.isAbsolute(from) ? from : this.join(this.cwd, from);
+        const absoluteTo = this.isAbsolute(to) ? to : this.join(this.cwd, to);
+        // if the paths are equal return an empty string
+        if (absoluteFrom === absoluteTo) {
+            return '';
+        }
+        const matching = [];
+        // split by / excluding the starting slash
+        const fromParts = this.join(absoluteFrom).split(/(?<!^)\//gm);
+        const toParts = this.join(absoluteTo).split(/(?<!^)\//gm);
+        for (let i = 0, max = toParts.length; i < max; i++) {
+            if (toParts[i] === fromParts?.[i]) {
+                matching.push(toParts[i]);
+            }
+            else {
+                break;
+            }
+        }
+        // calculate how many dirs we need to go up from the to path
+        const toUp = toParts.length - matching.length;
+        const fromUp = fromParts.length - matching.length;
+        // the max we have to go up
+        const up = Math.max(toUp, fromUp);
+        // if we have something from the 'from' to go up go up the max difference
+        const result = fromUp > 0 ? [...new Array(up).fill('..')] : [];
+        // if we have some parts left add them to the going up
+        if (toUp > 0) {
+            result.push(...toParts.slice(-toUp));
+        }
+        return result.join('/');
+    }
+    /** returns the directory name of a path */
+    dirname(path) {
+        const parts = this.join(path).split('/');
+        parts.pop();
+        // Preserve the initial slash if there was one.
+        if (parts.length === 1 && parts[0] === '') {
+            return '/';
+        }
+        return parts.join('/');
+    }
+    /** A platform independent version of path.join() */
+    join(...segments) {
+        return join(...segments);
+    }
+    /** Gracefully reads a file as JSON and parses it */
+    async readJSON(path) {
+        try {
+            return JSON.parse(await this.readFile(path));
+        }
+        catch (error) {
+            this.logger.error(`Could not parse JSON file ${path}\n${error}`);
+            return {};
+        }
+    }
+    /** Find a file or directory by walking up parent directories. */
+    async findUp(name, options = {}) {
+        let startDir = this.resolve(options.cwd || this.cwd);
+        // function for a recursive call
+        const readUp = async () => {
+            const entries = await this.readDir(startDir, true);
+            const found = Object.entries(entries).find(([entry, dirType]) => {
+                if ((typeof name === 'string' && entry === name) || (Array.isArray(name) && name.includes(entry))) {
+                    if (options.type) {
+                        if (options.type === dirType) {
+                            return entry;
+                        }
+                    }
+                    return entry;
+                }
+            });
+            // either found something or reached the root and nothing found
+            if (found?.[0]) {
+                return this.join(startDir, found[0]);
+            }
+            if (startDir === '/' || (options.stopAt && this.resolve(options.stopAt) === startDir)) {
+                return;
+            }
+            startDir = this.join(startDir, '..');
+            // recursive call to walk up
+            return readUp();
+        };
+        return readUp();
+    }
+    /** Find files or directories by walking up parent directories. */
+    async findUpMultiple(name, options = {}) {
+        let startDir = this.resolve(options.cwd || this.cwd);
+        const found = [];
+        // function for a recursive call
+        const readUp = async () => {
+            const entries = await this.readDir(startDir, true);
+            for (const [entry, dirType] of Object.entries(entries)) {
+                if ((typeof name === 'string' && entry === name) || (Array.isArray(name) && name.includes(entry))) {
+                    if ((options.type && options.type === dirType) || !options.type) {
+                        found.push(this.resolve(startDir, entry));
+                    }
+                }
+            }
+            if (startDir === '/' || (options.stopAt && this.resolve(options.stopAt) === startDir)) {
+                return found;
+            }
+            startDir = this.join(startDir, '..');
+            // recursive call to walk up
+            return readUp();
+        };
+        return readUp();
+    }
+}