@netlify/build 29.38.1 → 29.39.0

package/lib/core/feature_flags.js

@@ -15,4 +15,5 @@ export const DEFAULT_FEATURE_FLAGS = {
     buildbot_zisi_system_log: false,
     edge_functions_cache_cli: false,
     edge_functions_system_logger: false,
+    netlify_build_updated_plugin_compatibility: false,
 };

package/lib/plugins/compatibility.d.ts

@@ -1,4 +1,6 @@
 import { PackageJson } from 'read-pkg-up';
+import { FeatureFlags } from '../core/feature_flags.js';
+import { SystemLogger } from '../plugins_core/types.js';
 import { PluginVersion } from './list.js';
 /**
  *  Retrieve the `expectedVersion` of a plugin:
@@ -11,14 +13,18 @@ import { PluginVersion } from './list.js';
  *   - This is only used to print a warning message when the `compatibleVersion`
  *     is older than the currently used version.
  */
-export declare const getExpectedVersion: ({ versions, nodeVersion, packageJson, packagePath, buildDir, pinnedVersion, }: {
+export declare const getExpectedVersion: ({ versions, nodeVersion, packageJson, packageName, packagePath, buildDir, pinnedVersion, featureFlags, systemLog, authoritative, }: {
     versions: PluginVersion[];
     /** The package.json of the repository */
     packageJson: PackageJson;
+    packageName: string;
     packagePath?: string | undefined;
     buildDir: string;
     nodeVersion: string;
     pinnedVersion?: string | undefined;
+    featureFlags?: FeatureFlags | undefined;
+    systemLog: SystemLogger;
+    authoritative?: boolean | undefined;
 }) => Promise<{
     version: string;
     compatWarning: string;

package/lib/plugins/compatibility.js

@@ -15,14 +15,17 @@ const pEvery = _pEvery;
  *   - This is only used to print a warning message when the `compatibleVersion`
  *     is older than the currently used version.
  */
-export const getExpectedVersion = async function ({ versions, nodeVersion, packageJson, packagePath, buildDir, pinnedVersion, }) {
+export const getExpectedVersion = async function ({ versions, nodeVersion, packageJson, packageName, packagePath, buildDir, pinnedVersion, featureFlags, systemLog, authoritative, }) {
     const { version, conditions = [] } = await getCompatibleEntry({
         versions,
         nodeVersion,
         packageJson,
+        packageName,
         packagePath,
         buildDir,
         pinnedVersion,
+        featureFlags,
+        systemLog: authoritative ? systemLog : undefined,
     });
     // Retrieve warning message shown when using an older version with `compatibility`
     const compatWarning = conditions.map(({ type, condition }) => CONDITIONS[type].warning(condition)).join(', ');
@@ -44,12 +47,19 @@ export const getExpectedVersion = async function ({ versions, nodeVersion, packa
  *   - If there is a `pinnedVersion`, use it unless `latestVersion` matches it
  *   - Otherwise, use `latestVersion`
  */
-const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson, packagePath, buildDir, pinnedVersion, }) {
+const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson, packageName, packagePath, buildDir, pinnedVersion, featureFlags, systemLog = () => {
+    // no-op
+}, }) {
     const compatibleEntry = await pLocate(versions, async ({ version, overridePinnedVersion, conditions }) => {
-        // Detect if the overridePinnedVersion intersects with the pinned version in this case we don't care about filtering
+        // When there's a `pinnedVersion`, we typically pick the first version that
+        // matches that range. The exception is if `overridePinnedVersion` is also
+        // present. This property says that if the pinned version is within a given
+        // range, the entry that has this property can be used instead, even if its
+        // own version doesn't satisfy the pinned version.
         const overridesPin = Boolean(pinnedVersion && overridePinnedVersion && semver.intersects(overridePinnedVersion, pinnedVersion));
-        // ignore versions that don't satisfy the pinned version here if a pinned version is set
-        if (!overridesPin && pinnedVersion && !semver.satisfies(version, pinnedVersion, { includePrerelease: true })) {
+        // If there's a pinned version and this entry doesn't satisfy that range,
+        // discard it. The exception is if this entry overrides the pinned version.
+        if (pinnedVersion && !overridesPin && !semver.satisfies(version, pinnedVersion, { includePrerelease: true })) {
             return false;
         }
         // no conditions means nothing to filter
@@ -58,6 +68,43 @@ const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson,
         }
         return await pEvery(conditions, async ({ type, condition }) => CONDITIONS[type].test(condition, { nodeVersion, packageJson, packagePath, buildDir }));
     });
-    return (compatibleEntry ||
-        (pinnedVersion ? { version: pinnedVersion, conditions: [] } : { version: versions[0].version, conditions: [] }));
+    if (compatibleEntry) {
+        systemLog(`Used compatible version '${compatibleEntry.version}' for plugin '${packageName}' (pinned version is ${pinnedVersion})`);
+        return compatibleEntry;
+    }
+    if (pinnedVersion) {
+        systemLog(`Used pinned version '${pinnedVersion}' for plugin '${packageName}'`);
+        return { version: pinnedVersion, conditions: [] };
+    }
+    const legacyFallback = { version: versions[0].version, conditions: [] };
+    const fallback = await getFirstCompatibleEntry({ versions, nodeVersion, packageJson, packagePath, buildDir });
+    if (featureFlags?.netlify_build_updated_plugin_compatibility) {
+        if (legacyFallback.version !== fallback.version) {
+            systemLog(`Detected mismatch in selected version for plugin '${packageName}': used new version of '${fallback.version}' over legacy version '${legacyFallback.version}'`);
+        }
+        return fallback;
+    }
+    if (legacyFallback.version !== fallback.version) {
+        systemLog(`Detected mismatch in selected version for plugin '${packageName}': used legacy version '${legacyFallback.version}' over new version '${fallback.version}'`);
+    }
+    return legacyFallback;
+};
+/**
+ * Takes a list of plugin versions and returns the first entry that satisfies
+ * the conditions (if any), without taking into account the pinned version.
+ */
+const getFirstCompatibleEntry = async function ({ versions, nodeVersion, packageJson, packagePath, buildDir, }) {
+    const compatibleEntry = await pLocate(versions, async ({ conditions }) => {
+        if (conditions.length === 0) {
+            return true;
+        }
+        return await pEvery(conditions, async ({ type, condition }) => CONDITIONS[type].test(condition, { nodeVersion, packageJson, packagePath, buildDir }));
+    });
+    if (compatibleEntry) {
+        return compatibleEntry;
+    }
+    // We should never get here, because it means there are no plugin versions
+    // that we can install. We're keeping this here because it has been the
+    // default behavior for a long time, but we should look to remove it.
+    return { version: versions[0].version, conditions: [] };
 };

package/lib/plugins/compatibility.test.js

@@ -1,177 +1,298 @@
-import { expect, test } from 'vitest';
+import { describe, expect, test } from 'vitest';
 import { getExpectedVersion } from './compatibility.js';
-test('`getExpectedVersion` should ignore the new major version if the version is pinned', async () => {
-    const versions = [
-        { version: '5.0.0', conditions: [] },
-        { version: '4.41.2', conditions: [] },
-    ];
-    const { version } = await getExpectedVersion({
-        versions,
-        nodeVersion: '18.19.0',
-        packageJson: {},
-        buildDir: '/some/path',
-        pinnedVersion: '4',
+const noopSystemLog = () => {
+    // no-op
+};
+describe(`getExpectedVersion`, () => {
+    test('should ignore the new major version if the version is pinned', async () => {
+        const versions = [
+            { version: '5.0.0', conditions: [] },
+            { version: '4.41.2', conditions: [] },
+        ];
+        const { version } = await getExpectedVersion({
+            versions,
+            nodeVersion: '18.19.0',
+            packageJson: {},
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '4',
+            systemLog: noopSystemLog,
+        });
+        expect(version).toBe('4.41.2');
     });
-    expect(version).toBe('4.41.2');
-});
-test('`getExpectedVersion` matches prerelease versions', async () => {
-    const versions = [
-        { version: '5.0.0', conditions: [] },
-        { version: '4.42.0-alpha.1', conditions: [] },
-        { version: '4.41.2', conditions: [] },
-    ];
-    const { version: version1 } = await getExpectedVersion({
-        versions,
-        nodeVersion: '18.19.0',
-        packageJson: {},
-        buildDir: '/some/path',
+    test('matches prerelease versions', async () => {
+        const versions = [
+            { version: '5.0.0', conditions: [] },
+            { version: '4.42.0-alpha.1', conditions: [] },
+            { version: '4.41.2', conditions: [] },
+        ];
+        const { version: version1 } = await getExpectedVersion({
+            versions,
+            nodeVersion: '18.19.0',
+            packageJson: {},
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            systemLog: noopSystemLog,
+        });
+        const { version: version2 } = await getExpectedVersion({
+            versions,
+            nodeVersion: '18.19.0',
+            packageJson: {},
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '4',
+            systemLog: noopSystemLog,
+        });
+        expect(version1).toBe('5.0.0');
+        expect(version2).toBe('4.42.0-alpha.1');
     });
-    const { version: version2 } = await getExpectedVersion({
-        versions,
-        nodeVersion: '18.19.0',
-        packageJson: {},
-        buildDir: '/some/path',
-        pinnedVersion: '4',
+    test('should retrieve a new major version if the overridePinnedVersion is specified', async () => {
+        const versions = [
+            { version: '5.0.0', conditions: [], overridePinnedVersion: '>=4.0.0' },
+            { version: '4.41.2', conditions: [] },
+        ];
+        const { version } = await getExpectedVersion({
+            versions,
+            nodeVersion: '18.19.0',
+            packageJson: {},
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '4',
+            systemLog: noopSystemLog,
+        });
+        expect(version).toBe('5.0.0');
     });
-    expect(version1).toBe('5.0.0');
-    expect(version2).toBe('4.42.0-alpha.1');
-});
-test('`getExpectedVersion`should retrieve a new major version if the overridePinnedVersion is specified', async () => {
-    const versions = [
-        { version: '5.0.0', conditions: [], overridePinnedVersion: '>=4.0.0' },
-        { version: '4.41.2', conditions: [] },
-    ];
-    const { version } = await getExpectedVersion({
-        versions,
-        nodeVersion: '18.19.0',
-        packageJson: {},
-        buildDir: '/some/path',
-        pinnedVersion: '4',
+    test('should retrieve the plugin based on the condition of a nodeVersion', async () => {
+        const versions = [
+            {
+                version: '4.42.0',
+                conditions: [{ type: 'nodeVersion', condition: '>=18.0.0' }],
+            },
+            { version: '4.41.2', conditions: [] },
+        ];
+        const { version } = await getExpectedVersion({
+            versions,
+            nodeVersion: '17.19.0',
+            packageJson: {},
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '4',
+            systemLog: noopSystemLog,
+        });
+        expect(version).toBe('4.41.2');
     });
-    expect(version).toBe('5.0.0');
-});
-test('`getExpectedVersion`should retrieve the plugin based on the condition of a nodeVersion', async () => {
-    const versions = [
-        {
-            version: '4.42.0',
-            conditions: [{ type: 'nodeVersion', condition: '>=18.0.0' }],
-        },
-        { version: '4.41.2', conditions: [] },
-    ];
-    const { version } = await getExpectedVersion({
-        versions,
-        nodeVersion: '17.19.0',
-        packageJson: {},
-        buildDir: '/some/path',
-        pinnedVersion: '4',
+    test('should retrieve the plugin based on conditions and feature flag due to pinned version', async () => {
+        const versions = [
+            {
+                version: '5.0.0-beta.1',
+                conditions: [
+                    { type: 'nodeVersion', condition: '>= 18.0.0' },
+                    { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
+                ],
+                overridePinnedVersion: '>=4.0.0',
+            },
+            {
+                version: '4.42.0',
+                conditions: [{ type: 'siteDependencies', condition: { next: '>=10.0.9' } }],
+            },
+            { version: '4.41.2', conditions: [] },
+            {
+                version: '3.9.2',
+                conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
+            },
+        ];
+        const { version: version1 } = await getExpectedVersion({
+            versions,
+            nodeVersion: '17.19.0',
+            packageJson: { dependencies: { next: '10.0.8' } },
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '3',
+            systemLog: noopSystemLog,
+        });
+        expect(version1).toBe('3.9.2');
+        const { version: version2 } = await getExpectedVersion({
+            versions,
+            nodeVersion: '17.19.0',
+            packageJson: { dependencies: { next: '11.0.0' } },
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '4',
+            systemLog: noopSystemLog,
+        });
+        expect(version2).toBe('4.42.0');
+        const { version: version3 } = await getExpectedVersion({
+            versions,
+            nodeVersion: '18.19.0',
+            packageJson: { dependencies: { next: '13.5.0' } },
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '4',
+            systemLog: noopSystemLog,
+        });
+        expect(version3).toBe('5.0.0-beta.1');
     });
-    expect(version).toBe('4.41.2');
-});
-test('`getExpectedVersion` should retrieve the plugin based on conditions and feature flag due to pinned version', async () => {
-    const versions = [
-        {
-            version: '5.0.0-beta.1',
-            conditions: [
-                { type: 'nodeVersion', condition: '>= 18.0.0' },
-                { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
-            ],
-            overridePinnedVersion: '>=4.0.0',
-        },
-        {
-            version: '4.42.0',
-            conditions: [{ type: 'siteDependencies', condition: { next: '>=10.0.9' } }],
-        },
-        { version: '4.41.2', conditions: [] },
-        {
-            version: '3.9.2',
-            conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
-        },
-    ];
-    const { version: version1 } = await getExpectedVersion({
-        versions,
-        nodeVersion: '17.19.0',
-        packageJson: { dependencies: { next: '10.0.8' } },
-        buildDir: '/some/path',
-        pinnedVersion: '3',
+    test('should work with rc versions inside the siteDependencies constraints', async () => {
+        const versions = [
+            {
+                version: '5.0.0-beta.1',
+                conditions: [
+                    { type: 'nodeVersion', condition: '>= 18.0.0' },
+                    { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
+                ],
+                overridePinnedVersion: '>=4.0.0',
+            },
+            {
+                version: '4.42.0',
+                conditions: [{ type: 'siteDependencies', condition: { next: '>=10.0.9' } }],
+            },
+            { version: '4.41.2', conditions: [] },
+            {
+                version: '3.9.2',
+                conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
+            },
+        ];
+        const { version } = await getExpectedVersion({
+            versions,
+            nodeVersion: '18.19.0',
+            packageJson: { dependencies: { next: '14.1.1-canary.36' } },
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '4',
+            systemLog: noopSystemLog,
+        });
+        expect(version).toBe('5.0.0-beta.1');
     });
-    expect(version1).toBe('3.9.2');
-    const { version: version2 } = await getExpectedVersion({
-        versions,
-        nodeVersion: '17.19.0',
-        packageJson: { dependencies: { next: '11.0.0' } },
-        buildDir: '/some/path',
-        pinnedVersion: '4',
+    test('should retrieve the plugin based on conditions and feature flag due to pinned version', async () => {
+        const versions = [
+            {
+                version: '5.0.0-beta.1',
+                conditions: [
+                    { type: 'nodeVersion', condition: '>= 18.0.0' },
+                    { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
+                ],
+                overridePinnedVersion: '>=4.0.0',
+            },
+            { version: '4.41.2', conditions: [] },
+            {
+                version: '3.9.2',
+                conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
+            },
+        ];
+        const { version: version1 } = await getExpectedVersion({
+            versions,
+            nodeVersion: '20.0.0',
+            packageJson: { dependencies: { next: '14.0.0' } },
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '4',
+            systemLog: noopSystemLog,
+        });
+        expect(version1).toBe('5.0.0-beta.1');
+        // out of range
+        const { version: version2 } = await getExpectedVersion({
+            versions,
+            nodeVersion: '20.0.0',
+            packageJson: { dependencies: { next: '13.0.0' } },
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '4',
+            systemLog: noopSystemLog,
+        });
+        expect(version2).toBe('4.41.2');
     });
-    expect(version2).toBe('4.42.0');
-    const { version: version3 } = await getExpectedVersion({
-        versions,
-        nodeVersion: '18.19.0',
-        packageJson: { dependencies: { next: '13.5.0' } },
-        buildDir: '/some/path',
-        pinnedVersion: '4',
+    test('matches the first entry that satisfies the constraints, even if it also matches another entry further down with more specific constraints', async () => {
+        const versions = [
+            { version: '4.41.2', conditions: [] },
+            {
+                version: '5.0.0-beta.1',
+                conditions: [
+                    { type: 'nodeVersion', condition: '>= 18.0.0' },
+                    { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
+                ],
+                overridePinnedVersion: '>=4.0.0',
+            },
+            {
+                version: '3.9.2',
+                conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
+            },
+        ];
+        const { version } = await getExpectedVersion({
+            versions,
+            nodeVersion: '20.0.0',
+            packageJson: { dependencies: { next: '14.0.0' } },
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            pinnedVersion: '4',
+            systemLog: noopSystemLog,
+        });
+        expect(version).toBe('4.41.2');
     });
-    expect(version3).toBe('5.0.0-beta.1');
-});
-test('`getExpectedVersion` should work with rc versions inside the siteDependencies constraints', async () => {
-    const versions = [
-        {
-            version: '5.0.0-beta.1',
-            conditions: [
-                { type: 'nodeVersion', condition: '>= 18.0.0' },
-                { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
-            ],
-            overridePinnedVersion: '>=4.0.0',
-        },
-        {
-            version: '4.42.0',
-            conditions: [{ type: 'siteDependencies', condition: { next: '>=10.0.9' } }],
-        },
-        { version: '4.41.2', conditions: [] },
-        {
-            version: '3.9.2',
-            conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
-        },
-    ];
-    const { version } = await getExpectedVersion({
-        versions,
-        nodeVersion: '18.19.0',
-        packageJson: { dependencies: { next: '14.1.1-canary.36' } },
-        buildDir: '/some/path',
-        pinnedVersion: '4',
-    });
-    expect(version).toBe('5.0.0-beta.1');
-});
-test('`getExpectedVersion` should retrieve the plugin based on conditions and feature flag due to pinned version', async () => {
-    const versions = [
-        {
-            version: '5.0.0-beta.1',
-            conditions: [
-                { type: 'nodeVersion', condition: '>= 18.0.0' },
-                { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
-            ],
-            overridePinnedVersion: '>=4.0.0',
-        },
-        { version: '4.41.2', conditions: [] },
-        {
-            version: '3.9.2',
-            conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
-        },
-    ];
-    const { version: version1 } = await getExpectedVersion({
-        versions,
-        nodeVersion: '20.0.0',
-        packageJson: { dependencies: { next: '14.0.0' } },
-        buildDir: '/some/path',
-        pinnedVersion: '4',
+    test('if no pinned version is set, it matches the first version regardless of whether its requirements match the conditions (legacy behavior)', async () => {
+        const versions = [
+            {
+                version: '5.0.0-beta.1',
+                conditions: [
+                    { type: 'nodeVersion', condition: '>= 18.0.0' },
+                    { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
+                ],
+                overridePinnedVersion: '>=4.0.0',
+            },
+            { version: '4.41.2', conditions: [] },
+            {
+                version: '3.9.2',
+                conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
+            },
+        ];
+        const logMessages = [];
+        const { version } = await getExpectedVersion({
+            versions,
+            nodeVersion: '20.0.0',
+            packageJson: { dependencies: { next: '12.0.0' } },
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            systemLog: (message) => {
+                logMessages.push(message);
+            },
+            authoritative: true,
+        });
+        expect(logMessages.length).toBe(1);
+        expect(logMessages[0]).toBe(`Detected mismatch in selected version for plugin '@netlify/cool-plugin': used legacy version '5.0.0-beta.1' over new version '4.41.2'`);
+        expect(version).toBe('5.0.0-beta.1');
     });
-    expect(version1).toBe('5.0.0-beta.1');
-    // out of range
-    const { version: version2 } = await getExpectedVersion({
-        versions,
-        nodeVersion: '20.0.0',
-        packageJson: { dependencies: { next: '13.0.0' } },
-        buildDir: '/some/path',
-        pinnedVersion: '4',
+    test('if no pinned version is set, it matches the first version whose requirements match the conditions', async () => {
+        const versions = [
+            {
+                version: '5.0.0-beta.1',
+                conditions: [
+                    { type: 'nodeVersion', condition: '>= 18.0.0' },
+                    { type: 'siteDependencies', condition: { next: '>=13.5.0' } },
+                ],
+                overridePinnedVersion: '>=4.0.0',
+            },
+            { version: '4.41.2', conditions: [] },
+            {
+                version: '3.9.2',
+                conditions: [{ type: 'siteDependencies', condition: { next: '<10.0.9' } }],
+            },
+        ];
+        const logMessages = [];
+        const { version } = await getExpectedVersion({
+            versions,
+            nodeVersion: '20.0.0',
+            packageJson: { dependencies: { next: '12.0.0' } },
+            packageName: '@netlify/cool-plugin',
+            buildDir: '/some/path',
+            systemLog: (message) => {
+                logMessages.push(message);
+            },
+            featureFlags: {
+                netlify_build_updated_plugin_compatibility: true,
+            },
+            authoritative: true,
+        });
+        expect(logMessages.length).toBe(1);
+        expect(logMessages[0]).toBe(`Detected mismatch in selected version for plugin '@netlify/cool-plugin': used new version of '4.41.2' over legacy version '5.0.0-beta.1'`);
+        expect(version).toBe('4.41.2');
     });
-    expect(version2).toBe('4.41.2');
 });

package/lib/plugins/expected_version.d.ts

@@ -1,4 +1,4 @@
-export declare const addExpectedVersions: ({ pluginsOptions, autoPluginsDir, packageJson, packagePath, debug, logs, buildDir, testOpts, featureFlags, }: {
+export declare const addExpectedVersions: ({ pluginsOptions, autoPluginsDir, packageJson, packagePath, debug, logs, buildDir, testOpts, featureFlags, systemLog, }: {
     pluginsOptions: any;
     autoPluginsDir: any;
     packageJson: any;
@@ -8,4 +8,5 @@ export declare const addExpectedVersions: ({ pluginsOptions, autoPluginsDir, pac
     buildDir: any;
     testOpts: any;
     featureFlags: any;
+    systemLog: any;
 }) => Promise<any>;

package/lib/plugins/expected_version.js

@@ -7,7 +7,7 @@ import { getPluginsList } from './list.js';
 // When using plugins in our official list, those are installed in .netlify/plugins/
 // We ensure that the last version that's been approved is always the one being used.
 // We also ensure that the plugin is our official list.
-export const addExpectedVersions = async function ({ pluginsOptions, autoPluginsDir, packageJson, packagePath, debug, logs, buildDir, testOpts, featureFlags, }) {
+export const addExpectedVersions = async function ({ pluginsOptions, autoPluginsDir, packageJson, packagePath, debug, logs, buildDir, testOpts, featureFlags, systemLog, }) {
     if (!pluginsOptions.some(needsExpectedVersion)) {
         return pluginsOptions;
     }
@@ -21,10 +21,11 @@ export const addExpectedVersions = async function ({ pluginsOptions, autoPlugins
         buildDir,
         featureFlags,
         testOpts,
+        systemLog,
     })));
 };
 /** Any `pluginOptions` with `expectedVersion` set will be automatically installed */
-const addExpectedVersion = async function ({ pluginsList, autoPluginsDir, packageJson, packagePath, pluginOptions, pluginOptions: { packageName, pluginPath, loadedFrom, nodeVersion, pinnedVersion }, buildDir, featureFlags, testOpts, }) {
+const addExpectedVersion = async function ({ pluginsList, autoPluginsDir, packageJson, packagePath, pluginOptions, pluginOptions: { packageName, pluginPath, loadedFrom, nodeVersion, pinnedVersion }, buildDir, featureFlags, testOpts, systemLog, }) {
     if (!needsExpectedVersion(pluginOptions)) {
         return pluginOptions;
     }
@@ -36,8 +37,28 @@ const addExpectedVersion = async function ({ pluginsList, autoPluginsDir, packag
     const versions = filterVersions(unfilteredVersions, featureFlags);
     const [{ version: latestVersion, migrationGuide }] = versions;
     const [{ version: expectedVersion }, { version: compatibleVersion, compatWarning }] = await Promise.all([
-        getExpectedVersion({ versions, nodeVersion, packageJson, packagePath, buildDir, pinnedVersion }),
-        getExpectedVersion({ versions, nodeVersion, packageJson, packagePath, buildDir }),
+        getExpectedVersion({
+            versions,
+            nodeVersion,
+            packageJson,
+            packageName,
+            packagePath,
+            buildDir,
+            pinnedVersion,
+            featureFlags,
+            systemLog,
+            authoritative: true,
+        }),
+        getExpectedVersion({
+            versions,
+            nodeVersion,
+            packageJson,
+            packageName,
+            packagePath,
+            buildDir,
+            featureFlags,
+            systemLog,
+        }),
     ]);
     const isMissing = await isMissingVersion({ autoPluginsDir, packageName, pluginPath, loadedFrom, expectedVersion });
     return {

package/lib/plugins/resolve.js

@@ -33,6 +33,7 @@ export const resolvePluginsPath = async function ({ pluginsOptions, siteInfo, bu
         buildDir,
         testOpts,
         featureFlags,
+        systemLog,
     });
     const pluginsOptionsE = await handleMissingPlugins({
         pluginsOptions: pluginsOptionsD,

package/lib/plugins_core/blobs_upload/index.d.ts

@@ -1,2 +1,2 @@
-import { CoreStep } from '../types.js';
+import { type CoreStep } from '../types.js';
 export declare const uploadBlobs: CoreStep;

package/lib/plugins_core/blobs_upload/index.js

@@ -3,8 +3,7 @@ import { getDeployStore } from '@netlify/blobs';
 import pMap from 'p-map';
 import semver from 'semver';
 import { log, logError } from '../../log/logger.js';
-import { scanForBlobs } from '../../utils/blobs.js';
-import { getKeysToUpload, getFileWithMetadata } from './utils.js';
+import { getFileWithMetadata, getKeysToUpload, scanForBlobs } from '../../utils/blobs.js';
 const coreStep = async function ({ debug, logs, deployId, buildDir, quiet, packagePath, constants: { SITE_ID, NETLIFY_API_TOKEN, NETLIFY_API_HOST }, }) {
     // This should never happen due to the condition check
     if (!deployId || !NETLIFY_API_TOKEN) {
@@ -20,10 +19,8 @@ const coreStep = async function ({ debug, logs, deployId, buildDir, quiet, packa
     };
     // If we don't have native `fetch` in the global scope, add a polyfill.
     if (semver.lt(nodeVersion, '18.0.0')) {
-        const nodeFetch = await import('node-fetch');
-        // @ts-expect-error The types between `node-fetch` and the native `fetch`
-        // are not a 100% match, even though the APIs are mostly compatible.
-        storeOpts.fetch = nodeFetch.default;
+        const nodeFetch = (await import('node-fetch')).default;
+        storeOpts.fetch = nodeFetch;
     }
     const blobs = await scanForBlobs(buildDir, packagePath);
     // We checked earlier, but let's be extra safe
@@ -49,15 +46,14 @@ const coreStep = async function ({ debug, logs, deployId, buildDir, quiet, packa
     if (!quiet) {
         log(logs, `Uploading ${keys.length} blobs to deploy store...`);
     }
-    const uploadBlob = async (key) => {
-        if (debug && !quiet) {
-            log(logs, `- Uploading blob ${key}`, { indent: true });
-        }
-        const { data, metadata } = await getFileWithMetadata(blobs.directory, key);
-        await blobStore.set(key, data, { metadata });
-    };
     try {
-        await pMap(keys, uploadBlob, { concurrency: 10 });
+        await pMap(keys, async (key) => {
+            if (debug && !quiet) {
+                log(logs, `- Uploading blob ${key}`, { indent: true });
+            }
+            const { data, metadata } = await getFileWithMetadata(blobs.directory, key);
+            await blobStore.set(key, data, { metadata });
+        }, { concurrency: 10 });
     }
     catch (err) {
         logError(logs, `Error uploading blobs to deploy store: ${err.message}`);

package/lib/plugins_core/dev_blobs_upload/index.d.ts

@@ -0,0 +1,2 @@
+import { type CoreStep } from '../types.js';
+export declare const devUploadBlobs: CoreStep;

package/lib/plugins_core/dev_blobs_upload/index.js

@@ -0,0 +1,75 @@
+import { version as nodeVersion } from 'node:process';
+import { getDeployStore } from '@netlify/blobs';
+import pMap from 'p-map';
+import semver from 'semver';
+import { log, logError } from '../../log/logger.js';
+import { getFileWithMetadata, getKeysToUpload, scanForBlobs } from '../../utils/blobs.js';
+const coreStep = async function ({ debug, logs, deployId, buildDir, quiet, packagePath, constants: { SITE_ID, NETLIFY_API_TOKEN, NETLIFY_API_HOST }, }) {
+    // This should never happen due to the condition check
+    if (!deployId || !NETLIFY_API_TOKEN) {
+        return {};
+    }
+    // for cli deploys with `netlify deploy --build` the `NETLIFY_API_HOST` is undefined
+    const apiHost = NETLIFY_API_HOST || 'api.netlify.com';
+    const storeOpts = {
+        siteID: SITE_ID,
+        deployID: deployId,
+        token: NETLIFY_API_TOKEN,
+        apiURL: `https://${apiHost}`,
+    };
+    // If we don't have native `fetch` in the global scope, add a polyfill.
+    if (semver.lt(nodeVersion, '18.0.0')) {
+        const nodeFetch = (await import('node-fetch')).default;
+        storeOpts.fetch = nodeFetch;
+    }
+    const blobs = await scanForBlobs(buildDir, packagePath);
+    // We checked earlier, but let's be extra safe
+    if (blobs === null) {
+        if (!quiet) {
+            log(logs, 'No blobs to upload to deploy store.');
+        }
+        return {};
+    }
+    // If using the deploy config API, configure the store to use the region that
+    // was configured for the deploy.
+    if (!blobs.isLegacyDirectory) {
+        storeOpts.experimentalRegion = 'auto';
+    }
+    const blobStore = getDeployStore(storeOpts);
+    const keys = await getKeysToUpload(blobs.directory);
+    if (keys.length === 0) {
+        if (!quiet) {
+            log(logs, 'No blobs to upload to deploy store.');
+        }
+        return {};
+    }
+    if (!quiet) {
+        log(logs, `Uploading ${keys.length} blobs to deploy store...`);
+    }
+    try {
+        await pMap(keys, async (key) => {
+            if (debug && !quiet) {
+                log(logs, `- Uploading blob ${key}`, { indent: true });
+            }
+            const { data, metadata } = await getFileWithMetadata(blobs.directory, key);
+            await blobStore.set(key, data, { metadata });
+        }, { concurrency: 10 });
+    }
+    catch (err) {
+        logError(logs, `Error uploading blobs to deploy store: ${err.message}`);
+        throw new Error(`Failed while uploading blobs to deploy store`);
+    }
+    if (!quiet) {
+        log(logs, `Done uploading blobs to deploy store.`);
+    }
+    return {};
+};
+const deployAndBlobsPresent = async ({ deployId, buildDir, packagePath, constants: { NETLIFY_API_TOKEN }, }) => Boolean(NETLIFY_API_TOKEN && deployId && (await scanForBlobs(buildDir, packagePath)));
+export const devUploadBlobs = {
+    event: 'onDev',
+    coreStep,
+    coreStepId: 'dev_blobs_upload',
+    coreStepName: 'Uploading blobs',
+    coreStepDescription: () => 'Uploading blobs to development deploy store',
+    condition: deployAndBlobsPresent,
+};

package/lib/steps/get.js

@@ -4,6 +4,7 @@ import { uploadBlobs } from '../plugins_core/blobs_upload/index.js';
 import { buildCommandCore } from '../plugins_core/build_command.js';
 import { deploySite } from '../plugins_core/deploy/index.js';
 import { applyDeployConfig } from '../plugins_core/deploy_config/index.js';
+import { devUploadBlobs } from '../plugins_core/dev_blobs_upload/index.js';
 import { bundleEdgeFunctions } from '../plugins_core/edge_functions/index.js';
 import { bundleFunctions } from '../plugins_core/functions/index.js';
 import { preCleanup } from '../plugins_core/pre_cleanup/index.js';
@@ -32,7 +33,7 @@ export const getDevSteps = function (command, steps, eventHandlers) {
         coreStepDescription: () => 'Run command for local development',
     };
     const eventSteps = getEventSteps(eventHandlers);
-    const sortedSteps = sortSteps([preDevCleanup, ...steps, eventSteps, devCommandStep], DEV_EVENTS);
+    const sortedSteps = sortSteps([preDevCleanup, ...steps, devUploadBlobs, eventSteps, devCommandStep], DEV_EVENTS);
     const events = getEvents(sortedSteps);
     return { steps: sortedSteps, events };
 };

package/lib/utils/blobs.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
 /** Retrieve the absolute path of the deploy scoped internal blob directories */
 export declare const getBlobsDirs: (buildDir: string, packagePath?: string) => string[];
 /**
@@ -13,3 +14,10 @@ export declare const scanForBlobs: (buildDir: string, packagePath?: string) => P
     directory: string;
     isLegacyDirectory: boolean;
 } | null>;
+/** Given output directory, find all file paths to upload excluding metadata files */
+export declare const getKeysToUpload: (blobsDir: string) => Promise<string[]>;
+/** Read a file and its metadata file from the blobs directory */
+export declare const getFileWithMetadata: (blobsDir: string, key: string) => Promise<{
+    data: Buffer;
+    metadata: Record<string, string>;
+}>;

package/lib/utils/blobs.js

@@ -1,11 +1,12 @@
-import { resolve } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
 import { fdir } from 'fdir';
 const LEGACY_BLOBS_PATH = '.netlify/blobs/deploy';
 const DEPLOY_CONFIG_BLOBS_PATH = '.netlify/deploy/v1/blobs/deploy';
 /** Retrieve the absolute path of the deploy scoped internal blob directories */
 export const getBlobsDirs = (buildDir, packagePath) => [
-    resolve(buildDir, packagePath || '', DEPLOY_CONFIG_BLOBS_PATH),
-    resolve(buildDir, packagePath || '', LEGACY_BLOBS_PATH),
+    path.resolve(buildDir, packagePath || '', DEPLOY_CONFIG_BLOBS_PATH),
+    path.resolve(buildDir, packagePath || '', LEGACY_BLOBS_PATH),
 ];
 /**
  * Detect if there are any blobs to upload, and if so, what directory they're
@@ -17,7 +18,7 @@ export const getBlobsDirs = (buildDir, packagePath) => [
  * @returns
  */
 export const scanForBlobs = async function (buildDir, packagePath) {
-    const blobsDir = resolve(buildDir, packagePath || '', DEPLOY_CONFIG_BLOBS_PATH);
+    const blobsDir = path.resolve(buildDir, packagePath || '', DEPLOY_CONFIG_BLOBS_PATH);
     const blobsDirScan = await new fdir().onlyCounts().crawl(blobsDir).withPromise();
     if (blobsDirScan.files > 0) {
         return {
@@ -25,7 +26,7 @@ export const scanForBlobs = async function (buildDir, packagePath) {
             isLegacyDirectory: false,
         };
     }
-    const legacyBlobsDir = resolve(buildDir, packagePath || '', LEGACY_BLOBS_PATH);
+    const legacyBlobsDir = path.resolve(buildDir, packagePath || '', LEGACY_BLOBS_PATH);
     const legacyBlobsDirScan = await new fdir().onlyCounts().crawl(legacyBlobsDir).withPromise();
     if (legacyBlobsDirScan.files > 0) {
         return {
@@ -35,3 +36,46 @@ export const scanForBlobs = async function (buildDir, packagePath) {
     }
     return null;
 };
+const METADATA_PREFIX = '$';
+const METADATA_SUFFIX = '.json';
+/** Given output directory, find all file paths to upload excluding metadata files */
+export const getKeysToUpload = async (blobsDir) => {
+    const files = await new fdir()
+        .withRelativePaths() // we want the relative path from the blobsDir
+        .filter((fpath) => !path.basename(fpath).startsWith(METADATA_PREFIX))
+        .crawl(blobsDir)
+        .withPromise();
+    // normalize the path separators to all use the forward slash
+    return files.map((f) => f.split(path.sep).join('/'));
+};
+/** Read a file and its metadata file from the blobs directory */
+export const getFileWithMetadata = async (blobsDir, key) => {
+    const contentPath = path.join(blobsDir, key);
+    const dirname = path.dirname(key);
+    const basename = path.basename(key);
+    const metadataPath = path.join(blobsDir, dirname, `${METADATA_PREFIX}${basename}${METADATA_SUFFIX}`);
+    const [data, metadata] = await Promise.all([readFile(contentPath), readMetadata(metadataPath)]).catch((err) => {
+        throw new Error(`Failed while reading '${key}' and its metadata: ${err.message}`);
+    });
+    return { data, metadata };
+};
+const readMetadata = async (metadataPath) => {
+    let metadataFile;
+    try {
+        metadataFile = await readFile(metadataPath, { encoding: 'utf8' });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            // no metadata file found, that's ok
+            return {};
+        }
+        throw err;
+    }
+    try {
+        return JSON.parse(metadataFile);
+    }
+    catch {
+        // Normalize the error message
+        throw new Error(`Error parsing metadata file '${metadataPath}'`);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.38.1",
+  "version": "29.39.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -68,17 +68,17 @@
   "license": "MIT",
   "dependencies": {
     "@bugsnag/js": "^7.0.0",
-    "@netlify/blobs": "^7.2.0",
+    "@netlify/blobs": "^7.3.0",
     "@netlify/cache-utils": "^5.1.5",
     "@netlify/config": "^20.12.1",
     "@netlify/edge-bundler": "11.3.0",
     "@netlify/framework-info": "^9.8.11",
-    "@netlify/functions-utils": "^5.2.52",
+    "@netlify/functions-utils": "^5.2.53",
     "@netlify/git-utils": "^5.1.1",
     "@netlify/opentelemetry-utils": "^1.1.0",
     "@netlify/plugins-list": "^6.77.0",
     "@netlify/run-utils": "^5.1.1",
-    "@netlify/zip-it-and-ship-it": "9.31.0",
+    "@netlify/zip-it-and-ship-it": "9.31.1",
     "@sindresorhus/slugify": "^2.0.0",
     "ansi-escapes": "^6.0.0",
     "chalk": "^5.0.0",
@@ -164,5 +164,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "decb312a4cbaa1a18c2787b28d8e83b32b34dbe5"
+  "gitHead": "1594f6b29e2fcaf9b57fc0938af0d352d74374c1"
 }

package/lib/plugins_core/blobs_upload/utils.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/** Given output directory, find all file paths to upload excluding metadata files */
-export declare function getKeysToUpload(blobsDir: string): Promise<string[]>;
-/** Read a file and its metadata file from the blobs directory */
-export declare function getFileWithMetadata(blobsDir: string, key: string): Promise<{
-    data: Buffer;
-    metadata: Record<string, string>;
-}>;

package/lib/plugins_core/blobs_upload/utils.js

@@ -1,46 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { fdir } from 'fdir';
-const METADATA_PREFIX = '$';
-const METADATA_SUFFIX = '.json';
-/** Given output directory, find all file paths to upload excluding metadata files */
-export async function getKeysToUpload(blobsDir) {
-    const files = await new fdir()
-        .withRelativePaths() // we want the relative path from the blobsDir
-        .filter((fpath) => !path.basename(fpath).startsWith(METADATA_PREFIX))
-        .crawl(blobsDir)
-        .withPromise();
-    // normalize the path separators to all use the forward slash
-    return files.map((f) => f.split(path.sep).join('/'));
-}
-/** Read a file and its metadata file from the blobs directory */
-export async function getFileWithMetadata(blobsDir, key) {
-    const contentPath = path.join(blobsDir, key);
-    const dirname = path.dirname(key);
-    const basename = path.basename(key);
-    const metadataPath = path.join(blobsDir, dirname, `${METADATA_PREFIX}${basename}${METADATA_SUFFIX}`);
-    const [data, metadata] = await Promise.all([readFile(contentPath), readMetadata(metadataPath)]).catch((err) => {
-        throw new Error(`Failed while reading '${key}' and its metadata: ${err.message}`);
-    });
-    return { data, metadata };
-}
-async function readMetadata(metadataPath) {
-    let metadataFile;
-    try {
-        metadataFile = await readFile(metadataPath, { encoding: 'utf8' });
-    }
-    catch (err) {
-        if (err.code === 'ENOENT') {
-            // no metadata file found, that's ok
-            return {};
-        }
-        throw err;
-    }
-    try {
-        return JSON.parse(metadataFile);
-    }
-    catch {
-        // Normalize the error message
-        throw new Error(`Error parsing metadata file '${metadataPath}'`);
-    }
-}