@netlify/build 29.20.6 → 29.20.7

package/lib/core/bin.d.ts

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

package/lib/core/bin.js

@@ -5,7 +5,7 @@ import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { normalizeCliFeatureFlags } from './feature_flags.js';
 import { FLAGS } from './flags.js';
-import build from './main.js';
+import { buildSite } from './main.js';
 import { FALLBACK_SEVERITY_ENTRY } from './severity.js';
 // CLI entry point.
 // Before adding logic to this file, please consider adding it to the main
@@ -17,7 +17,7 @@ const runCli = async function () {
     const flagsA = includeKeys(flags, isUserFlag);
     const state = { done: false };
     process.on('exit', onExit.bind(undefined, state));
-    const { severityCode, logs } = await build(flagsA);
+    const { severityCode, logs } = await buildSite(flagsA);
     printLogs(logs);
     process.exitCode = severityCode;
     state.done = true;

package/lib/core/build.d.ts

@@ -0,0 +1,84 @@
+import type { BuildFlags } from './types.js';
+export declare const startBuild: (flags: Partial<BuildFlags>) => {
+    rootTracingContext: import("@opentelemetry/api").Context | undefined;
+    debug: boolean;
+    systemLogFile: number | undefined;
+    errorMonitor: any;
+    logs: import("../log/logger.js").BufferedLogs | undefined;
+    timers: never[];
+    env: Record<string, unknown>;
+    token: string;
+    mode: import("./types.js").Mode;
+    offline: boolean;
+    telemetry: boolean;
+    verbose: boolean;
+    functionsDistDir: string;
+    edgeFunctionsDistDir: string;
+    cacheDir: string;
+    sendStatus: boolean;
+    saveConfig: boolean;
+    apiHost?: string | undefined;
+    testOpts: import("./types.js").TestOptions;
+    statsd: {
+        port: number;
+    };
+    timeline: string;
+    cachedConfig: Record<string, unknown>;
+    siteId: string;
+    dry: false;
+    context: string;
+    statsdOpts: {
+        host?: number | undefined;
+        port: number;
+    };
+};
+export declare const execBuild: any;
+export declare const runAndReportBuild: ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, packagePath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, buildbotServerSocket, constants, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, timers, sendStatus, saveConfig, testOpts, featureFlags, timeline, devCommand, quiet, integrations, explicitSecretKeys, edgeFunctionsBootstrapURL, }: {
+    pluginsOptions: any;
+    netlifyConfig: any;
+    configOpts: any;
+    siteInfo: any;
+    configPath: any;
+    outputConfigPath: any;
+    headersPath: any;
+    redirectsPath: any;
+    packagePath: any;
+    buildDir: any;
+    repositoryRoot: any;
+    nodePath: any;
+    packageJson: any;
+    userNodeVersion: any;
+    childEnv: any;
+    context: any;
+    branch: any;
+    buildbotServerSocket: any;
+    constants: any;
+    dry: any;
+    mode: any;
+    api: any;
+    errorMonitor: any;
+    deployId: any;
+    errorParams: any;
+    logs: any;
+    debug: any;
+    systemLog: any;
+    verbose: any;
+    timers: any;
+    sendStatus: any;
+    saveConfig: any;
+    testOpts: any;
+    featureFlags: any;
+    timeline: any;
+    devCommand: any;
+    quiet: any;
+    integrations: any;
+    explicitSecretKeys: any;
+    edgeFunctionsBootstrapURL: any;
+}) => Promise<{
+    pluginsOptions: any;
+    netlifyConfig: any;
+    stepsCount: number | undefined;
+    timers: any;
+    configMutations: never[] | undefined;
+    metrics: never[] | undefined;
+}>;

package/lib/core/config.d.ts

@@ -0,0 +1,65 @@
+export function getConfigOpts({ config, defaultConfig, cwd, repositoryRoot, packagePath, apiHost, token, siteId, context, branch, baseRelDir, envOpt, mode, offline, deployId, buildId, testOpts, featureFlags, }: {
+    config: any;
+    defaultConfig: any;
+    cwd: any;
+    repositoryRoot: any;
+    packagePath: any;
+    apiHost: any;
+    token: any;
+    siteId: any;
+    context: any;
+    branch: any;
+    baseRelDir: any;
+    envOpt: any;
+    mode: any;
+    offline: any;
+    deployId: any;
+    buildId: any;
+    testOpts: any;
+    featureFlags: any;
+}): {
+    config: any;
+    defaultConfig: any;
+    cwd: any;
+    packagePath: any;
+    repositoryRoot: any;
+    context: any;
+    branch: any;
+    baseRelDir: any;
+    host: any;
+    token: any;
+    siteId: any;
+    deployId: any;
+    buildId: any;
+    mode: any;
+    offline: any;
+    env: any;
+    testOpts: any;
+    featureFlags: any;
+};
+export const loadConfig: any;
+export function resolveUpdatedConfig(configOpts: any, configMutations: any): Promise<any>;
+export function saveUpdatedConfig({ configMutations, buildDir, repositoryRoot, configPath, outputConfigPath, headersPath, redirectsPath, logs, featureFlags, context, branch, debug, saveConfig, }: {
+    configMutations: any;
+    buildDir: any;
+    repositoryRoot: any;
+    configPath?: string | undefined;
+    outputConfigPath?: any;
+    headersPath: any;
+    redirectsPath: any;
+    logs: any;
+    featureFlags: any;
+    context: any;
+    branch: any;
+    debug: any;
+    saveConfig: any;
+}): Promise<void>;
+export function restoreUpdatedConfig({ configMutations, buildDir, repositoryRoot, configPath, headersPath, redirectsPath, saveConfig, }: {
+    configMutations: any;
+    buildDir: any;
+    repositoryRoot: any;
+    configPath?: string | undefined;
+    headersPath: any;
+    redirectsPath: any;
+    saveConfig: any;
+}): Promise<void>;

package/lib/core/constants.d.ts

@@ -0,0 +1,26 @@
+export function getConstants({ configPath, buildDir, packagePath, functionsDistDir, edgeFunctionsDistDir, cacheDir, netlifyConfig, siteInfo: { id: siteId }, apiHost, token, mode, }: {
+    configPath: any;
+    buildDir: any;
+    packagePath: any;
+    functionsDistDir: any;
+    edgeFunctionsDistDir: any;
+    cacheDir: any;
+    netlifyConfig: any;
+    siteInfo: {
+        id: any;
+    };
+    apiHost: any;
+    token: any;
+    mode: any;
+}): Promise<Record<string, any> & Record<string, unknown>>;
+export function addMutableConstants({ constants, buildDir, netlifyConfig: { build: { publish, edge_functions: edgeFunctions }, functionsDirectory, }, }: {
+    constants: any;
+    buildDir: any;
+    netlifyConfig: {
+        build: {
+            publish: any;
+            edge_functions: any;
+        };
+        functionsDirectory: any;
+    };
+}): Promise<Record<string, any> & Record<string, unknown>>;

package/lib/core/dev.d.ts

@@ -0,0 +1,18 @@
+export function startDev(devCommand: any, flags?: {}): Promise<{
+    success: boolean;
+    severityCode: number;
+    netlifyConfig: any;
+    logs: import("../log/logger.js").BufferedLogs | undefined;
+    configMutations: any;
+    error?: undefined;
+} | {
+    success: boolean;
+    severityCode: number;
+    logs: import("../log/logger.js").BufferedLogs | undefined;
+    error: {
+        message: any;
+        stack: any;
+    };
+    netlifyConfig?: undefined;
+    configMutations?: undefined;
+}>;

package/lib/core/dry.d.ts

@@ -0,0 +1,8 @@
+export function doDryRun({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs }: {
+    buildDir: any;
+    steps: any;
+    netlifyConfig: any;
+    constants: any;
+    buildbotServerSocket: any;
+    logs: any;
+}): Promise<void>;

package/lib/core/feature_flags.d.ts

@@ -0,0 +1,3 @@
+export type FeatureFlags = Record<string, boolean>;
+export declare const normalizeCliFeatureFlags: (cliFeatureFlags: string) => FeatureFlags;
+export declare const DEFAULT_FEATURE_FLAGS: FeatureFlags;

package/lib/core/flags.d.ts

@@ -0,0 +1,230 @@
+export const FLAGS: {
+    config: {
+        string: boolean;
+        describe: string;
+    };
+    defaultConfig: {
+        string: boolean;
+        describe: string;
+        coerce: (value: any) => any;
+        hidden: boolean;
+    };
+    cachedConfig: {
+        string: boolean;
+        describe: string;
+        coerce: (value: any) => any;
+        hidden: boolean;
+    };
+    cachedConfigPath: {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    cwd: {
+        string: boolean;
+        describe: string;
+    };
+    repositoryRoot: {
+        string: boolean;
+        describe: string;
+    };
+    packagePath: {
+        string: boolean;
+        describe: string;
+    };
+    apiHost: {
+        string: boolean;
+        describe: string;
+    };
+    token: {
+        string: boolean;
+        describe: string;
+    };
+    siteId: {
+        string: boolean;
+        describe: string;
+    };
+    deployId: {
+        string: boolean;
+        describe: string;
+    };
+    buildId: {
+        string: boolean;
+        describe: string;
+    };
+    context: {
+        string: boolean;
+        describe: string;
+    };
+    branch: {
+        string: boolean;
+        describe: string;
+    };
+    framework: {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    baseRelDir: {
+        boolean: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    dry: {
+        alias: string;
+        boolean: boolean;
+        describe: string;
+    };
+    nodePath: {
+        string: boolean;
+        describe: string;
+    };
+    functionsDistDir: {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    edgeFunctionsDistDir: {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    cacheDir: {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    buildbotServerSocket: {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    telemetry: {
+        boolean: boolean;
+        describe: string;
+    };
+    mode: {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    debug: {
+        boolean: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    systemLogFile: {
+        type: string;
+        describe: string;
+        hidden: boolean;
+    };
+    verbose: {
+        boolean: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    sendStatus: {
+        boolean: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    saveConfig: {
+        boolean: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    outputConfigPath: {
+        type: string;
+        describe: string;
+        hidden: boolean;
+    };
+    testOpts: {
+        describe: string;
+        hidden: boolean;
+    };
+    featureFlags: {
+        describe: string;
+        hidden: boolean;
+    };
+    statsd: {
+        describe: string;
+        hidden: boolean;
+    };
+    'statsd.host': {
+        type: string;
+        describe: string;
+        hidden: boolean;
+    };
+    'statsd.port': {
+        type: string;
+        describe: string;
+        hidden: boolean;
+    };
+    tracing: {
+        describe: string;
+        hidden: boolean;
+    };
+    'tracing.enabled': {
+        boolean: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    'tracing.apiKey': {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    'tracing.httpProtocol': {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    'tracing.host': {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    'tracing.port': {
+        number: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    'tracing.traceId': {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    'tracing.parentSpanId': {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    'tracing.sampleRate': {
+        number: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    'tracing.traceFlags': {
+        number: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    offline: {
+        boolean: boolean;
+        describe: string;
+    };
+    buffer: {
+        boolean: boolean;
+        describe: string;
+    };
+    timeline: {
+        string: boolean;
+        describe: string;
+        hidden: boolean;
+    };
+    explicitSecretKeys: {
+        type: string;
+        describe: string;
+        hidden: boolean;
+    };
+};

package/lib/core/lingering.d.ts

@@ -0,0 +1,7 @@
+export function warnOnLingeringProcesses({ mode, logs, testOpts: { silentLingeringProcesses }, }: {
+    mode: any;
+    logs: any;
+    testOpts: {
+        silentLingeringProcesses?: boolean | undefined;
+    };
+}): Promise<void>;

package/lib/core/main.d.ts

@@ -0,0 +1,14 @@
+import { BuildFlags } from './types.js';
+/**
+ * Main entry point of Netlify Build.
+ * Runs a builds and returns whether it succeeded or not.
+ *
+ * @param flags - build configuration CLI flags
+ */
+export declare function buildSite(flags?: Partial<BuildFlags>): Promise<{
+    success: boolean;
+    severityCode: number;
+    logs: any;
+    netlifyConfig?: any;
+    configMutations?: any;
+}>;

package/lib/core/main.js

@@ -9,8 +9,6 @@ import { stopTracing, setMultiSpanAttributes } from '../tracing/main.js';
 import { execBuild, startBuild } from './build.js';
 import { reportMetrics } from './report_metrics.js';
 import { getSeverity } from './severity.js';
-export { startDev } from './dev.js';
-export { runCoreSteps } from '../steps/run_core_steps.js';
 const tracer = trace.getTracer('core');
 /**
  * Main entry point of Netlify Build.
@@ -18,7 +16,7 @@ const tracer = trace.getTracer('core');
  *
  * @param flags - build configuration CLI flags
  */
-export default async function buildSite(flags = {}) {
+export async function buildSite(flags = {}) {
     const { errorMonitor, framework, mode, logs, debug, systemLogFile, testOpts, statsdOpts, dry, telemetry, buildId, deployId, rootTracingContext, ...flagsA } = startBuild(flags);
     const errorParams = { errorMonitor, mode, logs, debug, testOpts };
     const systemLog = getSystemLogger(logs, debug, systemLogFile);

package/lib/core/missing_side_file.d.ts

@@ -0,0 +1,9 @@
+export function warnOnMissingSideFiles({ buildDir, netlifyConfig: { build: { publish }, }, logs, }: {
+    buildDir: any;
+    netlifyConfig: {
+        build: {
+            publish: any;
+        };
+    };
+    logs: any;
+}): Promise<void>;

package/lib/core/normalize_flags.d.ts

@@ -0,0 +1,38 @@
+import type { BuildFlags, Mode, TestOptions, TracingOptions } from './types.js';
+export type ResolvedFlags = {
+    env: Record<string, unknown>;
+    token: string;
+    mode: Mode;
+    offline: boolean;
+    telemetry: boolean;
+    verbose: boolean;
+    /** The dist directory of the functions @default `.netlify/functions/` */
+    functionsDistDir: string;
+    /** The dist directory of the edge functions @default `.netlify/edge-functions-dist/` */
+    edgeFunctionsDistDir: string;
+    /** The directory that is used for storing the cache @default `.netlify/cache/` */
+    cacheDir: string;
+    debug: boolean;
+    sendStatus: boolean;
+    saveConfig: boolean;
+    /** Netlify API endpoint @default `api.netlify.com` */
+    apiHost?: string;
+    testOpts: TestOptions;
+    statsd: {
+        port: number;
+    };
+    timeline: 'build' | string;
+    cachedConfig: Record<string, unknown>;
+    siteId: string;
+    dry: false;
+    context: 'production' | string;
+    statsdOpts: {
+        host?: number;
+        port: number;
+    };
+    bugsnagKey?: string;
+    systemLogFile?: number;
+    tracingOpts: TracingOptions;
+};
+/** Normalize CLI flags  */
+export declare const normalizeFlags: (flags: Partial<BuildFlags>, logs: any) => ResolvedFlags;

package/lib/core/report_metrics.d.ts

@@ -0,0 +1,12 @@
+import { InputStatsDOptions } from '../report/statsd.js';
+export type Metric = {
+    type: 'increment';
+    name: string;
+    value: number;
+    tags: Record<string, string | string[]>;
+};
+/**
+ * Record number of functions build and differentiate between autogenerated and user generated.
+ * Sends to statsd daemon.
+ */
+export declare const reportMetrics: (statsdOpts: InputStatsDOptions, metrics: Metric[]) => Promise<void>;

package/lib/core/severity.d.ts

@@ -0,0 +1,38 @@
+declare const SEVERITY_MAP: {
+    success: {
+        severityCode: number;
+        status: string;
+    };
+    none: {
+        severityCode: number;
+        status: string;
+    };
+    info: {
+        severityCode: number;
+        status: string;
+    };
+    warning: {
+        severityCode: number;
+        status: string;
+    };
+    error: {
+        severityCode: number;
+        status: string;
+    };
+};
+export type Severity = keyof typeof SEVERITY_MAP;
+/** Map error severities to exit codes and status (used for telemetry purposes) */
+export declare const FALLBACK_SEVERITY_ENTRY: {
+    severityCode: number;
+    status: string;
+};
+/**
+ * Used to extract exit codes and respective status strings
+ * 1|2|3 indicate whether this was a user|plugin|system error.
+ */
+export declare const getSeverity: (severity?: Severity) => {
+    severityCode: number;
+    status: string;
+    success: boolean;
+};
+export {};

package/lib/core/types.d.ts

@@ -0,0 +1,83 @@
+import { NetlifyConfig } from '../../types/index.js';
+export type Mode = 'buildbot' | 'cli' | 'require';
+export type BuildCLIFlags = {
+    cachedConfig: Record<string, unknown>;
+    /** Netlify Site ID */
+    siteId: string;
+    /** Netlify API token for authentication */
+    token: string;
+    /**
+     * Run in dry mode, i.e. printing steps without executing them
+     * @default false
+     */
+    dry: boolean;
+    debug?: unknown;
+    /** Build context */
+    context: 'production' | string;
+    /** The invoking service of netlify build */
+    mode: Mode;
+    telemetry: boolean;
+    /** Distributed tracing properties for this build*/
+    tracing: TracingOptions;
+    /**
+     * Buffer output instead of printing it
+     * @default false
+     */
+    buffer?: boolean;
+    offline: boolean;
+    cwd?: string;
+    /** A list of all the feature flags passed to netlify/build */
+    featureFlags: Record<string, boolean>;
+    /**
+     * Print only essential/error output
+     * @default false
+     */
+    quiet?: boolean;
+    statsd?: {
+        host?: string;
+        port?: number;
+    };
+};
+export type BuildFlags = BuildCLIFlags & {
+    env?: Record<string, unknown>;
+};
+export type BuildResult = {
+    success: boolean;
+    severityCode: SeverityCode;
+    netlifyConfig?: NetlifyConfig;
+    configMutations?: any;
+    logs?: string[];
+};
+export declare enum SeverityCode {
+    success = 1,
+    buildCancelled = 2,
+    userError = 3,
+    pluginError = 4,
+    systemError = 5
+}
+export type TestOptions = {
+    errorMonitor?: any;
+};
+export type ErrorParam = {
+    errorMonitor: any;
+    mode: Mode;
+    logs: string[];
+    debug: any;
+    testOpts?: TestOptions;
+    childEnv?: any;
+    netlifyConfig?: NetlifyConfig;
+};
+export type TracingOptions = {
+    enabled: boolean;
+    httpProtocol: string;
+    host: string;
+    port: number;
+    /** API Key used for a dedicated trace provider */
+    apiKey: string;
+    /** Sample rate being used for this trace, this allows for consistent probability sampling */
+    sampleRate: number;
+    /** Properties of the root span and trace id used to stitch context */
+    traceId: string;
+    traceFlags: number;
+    parentSpanId: string;
+};

package/lib/core/user_node_version.d.ts

@@ -0,0 +1 @@
+export function getUserNodeVersion(nodePath: any): Promise<string | null>;