@netlify/build-info 6.2.2 → 6.3.0

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/node/bin.js'

package/lib/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/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/build-systems/bazel.d.ts

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

package/lib/build-systems/bazel.js

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

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

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

package/lib/build-systems/buck.js

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

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

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

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

@@ -0,0 +1,18 @@
+export class BaseBuildTool {
+    id;
+    name;
+    version;
+    configFiles = [];
+    async detect(project) {
+        const config = await project.fs.findUp(this.configFiles, { cwd: project.baseDirectory, stopAt: project.root });
+        if (config) {
+            const pkgJson = await project.getPackageJSON(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/build-systems/gradle.d.ts

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

package/lib/build-systems/gradle.js

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

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

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

package/lib/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/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/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/build-systems/moon.d.ts

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

package/lib/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(project) {
+        const config = await project.fs.findUp(this.configFiles, {
+            cwd: project.baseDirectory,
+            type: 'directory',
+            stopAt: project.root,
+        });
+        if (config) {
+            const pkgJson = await project.getPackageJSON(config);
+            this.version = pkgJson.devDependencies?.[this.id];
+            return this;
+        }
+    }
+}

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

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

package/lib/build-systems/nix.js

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

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

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

package/lib/build-systems/nrwl.js

@@ -0,0 +1,11 @@
+import { BaseBuildTool } from './build-system.js';
+export class Nx extends BaseBuildTool {
+    id = 'nx';
+    name = 'Nx';
+    configFiles = ['nx.json'];
+}
+export class Lerna extends BaseBuildTool {
+    id = 'lerna';
+    name = 'Lerna';
+    configFiles = ['lerna.json'];
+}

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

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

package/lib/build-systems/pants.js

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

package/lib/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/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/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/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/file-system.d.ts

@@ -0,0 +1,69 @@
+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;
+};
+export declare abstract class FileSystem {
+    logger: Logger;
+    /**
+     * This is a in memory representation of the parsed files
+     * The keys are always stored in posix style
+     * If the value is null then the file did not get read up in memory yet.
+     * If the value is a string it already got read up in mem.
+     */
+    files: Map<string, File | null>;
+    /** 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;
+    /** adds a file to the file map */
+    setFile(path: string, content: File): void;
+    /** get a file from the file map */
+    getFile(path: string): File | null;
+    /** get a json file from the file map */
+    getJSONFile<T = Record<string, any>>(path: string): JSONFile<T> | null;
+    /** get a toml file from the file map */
+    getTOMLFile(path: string): TOMLFile | null;
+    /** Checks if a file is already in our in memory representation */
+    hasFile(path: any): boolean;
+    /** 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/file-system.js

@@ -0,0 +1,195 @@
+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);
+    }
+}
+export class FileSystem {
+    logger = new DefaultLogger();
+    /**
+     * This is a in memory representation of the parsed files
+     * The keys are always stored in posix style
+     * If the value is null then the file did not get read up in memory yet.
+     * If the value is a string it already got read up in mem.
+     */
+    files = new Map();
+    /** 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) {
+        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 ? '/' : '.');
+    }
+    /** adds a file to the file map */
+    setFile(path, content) {
+        this.files.set(path, content);
+    }
+    /** get a file from the file map */
+    getFile(path) {
+        return this.files.get(path) || null;
+    }
+    /** get a json file from the file map */
+    getJSONFile(path) {
+        const file = this.files.get(path) || null;
+        if (file?.type === 'json') {
+            return file;
+        }
+        return null;
+    }
+    /** get a toml file from the file map */
+    getTOMLFile(path) {
+        const file = this.files.get(path) || null;
+        if (file?.type === 'toml') {
+            return file;
+        }
+        return null;
+    }
+    /** Checks if a file is already in our in memory representation */
+    hasFile(path) {
+        const resolvedPath = path;
+        const file = this.files.get(resolvedPath);
+        return Boolean(file?.content);
+    }
+    /** Gracefully reads a file as JSON and parses it */
+    async readJSON(path) {
+        try {
+            const content = JSON.parse(await this.readFile(path));
+            this.files.set(path, { content, type: 'json' });
+            return content;
+        }
+        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();
+    }
+}

package/lib/index.d.ts

@@ -1 +1,2 @@
-export { getBuildInfo } from './get-build-info.js';
+export * from './file-system.js';
+export * from './project.js';

package/lib/index.js

@@ -1 +1,2 @@
-export { getBuildInfo } from './get-build-info.js';
+export * from './file-system.js';
+export * from './project.js';