@netlify/build 29.38.2 → 29.39.1

package/lib/plugins/compatibility.d.ts

@@ -13,16 +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, featureFlags, systemLog, }: {
+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,16 +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, featureFlags, systemLog, }) {
+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,
+        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(', ');
@@ -46,7 +47,9 @@ 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, featureFlags, systemLog, }) {
+const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson, packageName, packagePath, buildDir, pinnedVersion, featureFlags, systemLog = () => {
+    // no-op
+}, }) {
     const compatibleEntry = await pLocate(versions, async ({ version, overridePinnedVersion, conditions }) => {
         // When there's a `pinnedVersion`, we typically pick the first version that
         // matches that range. The exception is if `overridePinnedVersion` is also
@@ -66,21 +69,23 @@ const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson,
         return await pEvery(conditions, async ({ type, condition }) => CONDITIONS[type].test(condition, { nodeVersion, packageJson, packagePath, buildDir }));
     });
     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 '${packageJson?.name}': used new version of '${fallback.version}' over legacy version '${legacyFallback.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 '${packageJson?.name}': used legacy version '${legacyFallback.version}' over new version '${fallback.version}'`);
+        systemLog(`Detected mismatch in selected version for plugin '${packageName}': used legacy version '${legacyFallback.version}' over new version '${fallback.version}'`);
     }
     return legacyFallback;
 };

package/lib/plugins/compatibility.test.js

@@ -13,6 +13,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '18.19.0',
             packageJson: {},
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             pinnedVersion: '4',
             systemLog: noopSystemLog,
@@ -29,6 +30,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '18.19.0',
             packageJson: {},
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             systemLog: noopSystemLog,
         });
@@ -36,6 +38,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '18.19.0',
             packageJson: {},
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             pinnedVersion: '4',
             systemLog: noopSystemLog,
@@ -52,6 +55,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '18.19.0',
             packageJson: {},
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             pinnedVersion: '4',
             systemLog: noopSystemLog,
@@ -70,6 +74,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '17.19.0',
             packageJson: {},
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             pinnedVersion: '4',
             systemLog: noopSystemLog,
@@ -100,6 +105,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '17.19.0',
             packageJson: { dependencies: { next: '10.0.8' } },
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             pinnedVersion: '3',
             systemLog: noopSystemLog,
@@ -109,6 +115,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '17.19.0',
             packageJson: { dependencies: { next: '11.0.0' } },
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             pinnedVersion: '4',
             systemLog: noopSystemLog,
@@ -118,6 +125,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '18.19.0',
             packageJson: { dependencies: { next: '13.5.0' } },
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             pinnedVersion: '4',
             systemLog: noopSystemLog,
@@ -148,6 +156,7 @@ describe(`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,
@@ -174,6 +183,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '20.0.0',
             packageJson: { dependencies: { next: '14.0.0' } },
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             pinnedVersion: '4',
             systemLog: noopSystemLog,
@@ -184,6 +194,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '20.0.0',
             packageJson: { dependencies: { next: '13.0.0' } },
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             pinnedVersion: '4',
             systemLog: noopSystemLog,
@@ -210,6 +221,7 @@ describe(`getExpectedVersion`, () => {
             versions,
             nodeVersion: '20.0.0',
             packageJson: { dependencies: { next: '14.0.0' } },
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             pinnedVersion: '4',
             systemLog: noopSystemLog,
@@ -236,14 +248,16 @@ describe(`getExpectedVersion`, () => {
         const { version } = await getExpectedVersion({
             versions,
             nodeVersion: '20.0.0',
-            packageJson: { name: '@netlify/a-cool-plugin', dependencies: { next: '12.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/a-cool-plugin': used legacy version '5.0.0-beta.1' over new version '4.41.2'`);
+        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');
     });
     test('if no pinned version is set, it matches the first version whose requirements match the conditions', async () => {
@@ -266,7 +280,8 @@ describe(`getExpectedVersion`, () => {
         const { version } = await getExpectedVersion({
             versions,
             nodeVersion: '20.0.0',
-            packageJson: { name: '@netlify/a-cool-plugin', dependencies: { next: '12.0.0' } },
+            packageJson: { dependencies: { next: '12.0.0' } },
+            packageName: '@netlify/cool-plugin',
             buildDir: '/some/path',
             systemLog: (message) => {
                 logMessages.push(message);
@@ -274,9 +289,10 @@ describe(`getExpectedVersion`, () => {
             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/a-cool-plugin': used new version of '4.41.2' over legacy version '5.0.0-beta.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');
     });
 });

package/lib/plugins/expected_version.js

@@ -41,13 +41,24 @@ const addExpectedVersion = async function ({ pluginsList, autoPluginsDir, packag
             versions,
             nodeVersion,
             packageJson,
+            packageName,
             packagePath,
             buildDir,
             pinnedVersion,
             featureFlags,
             systemLog,
+            authoritative: true,
+        }),
+        getExpectedVersion({
+            versions,
+            nodeVersion,
+            packageJson,
+            packageName,
+            packagePath,
+            buildDir,
+            featureFlags,
+            systemLog,
         }),
-        getExpectedVersion({ versions, nodeVersion, packageJson, packagePath, buildDir, featureFlags, systemLog }),
     ]);
     const isMissing = await isMissingVersion({ autoPluginsDir, packageName, pluginPath, loadedFrom, expectedVersion });
     return {

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.2",
+  "version": "29.39.1",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -73,12 +73,12 @@
     "@netlify/config": "^20.12.1",
     "@netlify/edge-bundler": "11.3.0",
     "@netlify/framework-info": "^9.8.11",
-    "@netlify/functions-utils": "^5.2.53",
+    "@netlify/functions-utils": "^5.2.54",
     "@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.1",
+    "@netlify/zip-it-and-ship-it": "9.31.3",
     "@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": "f172805567a263a78956981106526411a9050644"
+  "gitHead": "b06aeddfb79f5d60d0fe8e66cebcb1e8eaa29f90"
 }

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}'`);
-    }
-}