@netlify/config 23.2.0 → 24.0.0

package/lib/api/site_info.d.ts

@@ -1,7 +1,7 @@
 import { NetlifyAPI } from '@netlify/api';
-import { IntegrationResponse } from '../types/api.js';
+import * as z from 'zod';
 import { ModeOption, TestOptions } from '../types/options.js';
-type GetSiteInfoOpts = {
+type GetSiteInfoOptions = {
     siteId: string;
     accountId?: string;
     mode: ModeOption;
@@ -14,6 +14,22 @@ type GetSiteInfoOpts = {
     token: string;
     extensionApiBaseUrl: string;
 };
+export type Extension = {
+    author: string | undefined;
+    extension_token: string | undefined;
+    has_build: boolean;
+    name: string;
+    slug: string;
+    version: string;
+};
+export type SiteInfo = {
+    accounts: MinimalAccount[];
+    extensions: Extension[];
+    siteInfo: Awaited<ReturnType<NetlifyAPI['getSite']>> & {
+        feature_flags?: Record<string, string | number | boolean>;
+        use_envelope?: boolean;
+    };
+};
 /**
  * Retrieve Netlify Site information, if available.
  * Used to retrieve local build environment variables and UI build settings.
@@ -23,11 +39,7 @@ type GetSiteInfoOpts = {
  * Silently ignore API errors. For example the network connection might be down,
  * but local builds should still work regardless.
  */
-export declare const getSiteInfo: ({ api, siteId, accountId, mode, context, offline, testOpts, siteFeatureFlagPrefix, token, featureFlags, extensionApiBaseUrl, }: GetSiteInfoOpts) => Promise<{
-    siteInfo: any;
-    accounts: MinimalAccount[];
-    integrations: IntegrationResponse[];
-}>;
+export declare const getSiteInfo: ({ api, siteId, accountId, mode, context, offline, testOpts, siteFeatureFlagPrefix, token, featureFlags, extensionApiBaseUrl, }: GetSiteInfoOptions) => Promise<SiteInfo>;
 export type MinimalAccount = {
     id: string;
     name: string;
@@ -40,7 +52,16 @@ export type MinimalAccount = {
     type_slug: string;
     members_count: number;
 };
-type GetIntegrationsOpts = {
+declare const ExtensionResponseSchema: z.ZodArray<z.ZodObject<{
+    author: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    extension_token: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    has_build: z.ZodBoolean;
+    name: z.ZodString;
+    slug: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strip>>;
+export type ExtensionResponse = z.output<typeof ExtensionResponseSchema>;
+type GetExtensionsOptions = {
     siteId?: string;
     accountId?: string;
     testOpts: TestOptions;
@@ -50,5 +71,5 @@ type GetIntegrationsOpts = {
     extensionApiBaseUrl: string;
     mode: ModeOption;
 };
-export declare const getIntegrations: ({ siteId, accountId, testOpts, offline, token, featureFlags, extensionApiBaseUrl, mode, }: GetIntegrationsOpts) => Promise<IntegrationResponse[]>;
+export declare const getExtensions: ({ siteId, accountId, testOpts, offline, token, featureFlags, extensionApiBaseUrl, mode, }: GetExtensionsOptions) => Promise<Extension[]>;
 export {};

package/lib/api/site_info.js

@@ -1,7 +1,9 @@
+import * as z from 'zod';
 import { getEnvelope } from '../env/envelope.js';
 import { throwUserError } from '../error.js';
-import { EXTENSION_API_BASE_URL, EXTENSION_API_STAGING_BASE_URL, NETLIFY_API_BASE_URL, NETLIFY_API_STAGING_BASE_URL, } from '../integrations.js';
+import { EXTENSION_API_BASE_URL, EXTENSION_API_STAGING_BASE_URL, NETLIFY_API_HOSTNAME, NETLIFY_API_STAGING_HOSTNAME, } from '../extensions.js';
 import { ERROR_CALL_TO_ACTION } from '../log/messages.js';
+import { ROOT_PACKAGE_JSON } from '../utils/json.js';
 /**
  * Retrieve Netlify Site information, if available.
  * Used to retrieve local build environment variables and UI build settings.
@@ -15,12 +17,15 @@ export const getSiteInfo = async function ({ api, siteId, accountId, mode, conte
     const { env: testEnv = false } = testOpts;
     if (api === undefined || mode === 'buildbot' || testEnv) {
         const siteInfo = {};
-        if (siteId !== undefined)
+        if (siteId !== undefined) {
             siteInfo.id = siteId;
-        if (accountId !== undefined)
+        }
+        if (accountId !== undefined) {
             siteInfo.account_id = accountId;
-        const integrations = mode === 'buildbot' && !offline
-            ? await getIntegrations({
+        }
+        let extensions = [];
+        if (mode === 'buildbot' && !offline) {
+            extensions = await getExtensions({
                 siteId,
                 testOpts,
                 offline,
@@ -29,31 +34,38 @@ export const getSiteInfo = async function ({ api, siteId, accountId, mode, conte
                 featureFlags,
                 extensionApiBaseUrl,
                 mode,
-            })
-            : [];
-        return { siteInfo, accounts: [], integrations };
+            });
+        }
+        return { accounts: [], extensions, siteInfo };
     }
-    const [siteInfo, accounts, integrations] = await Promise.all([
+    const [siteInfo, accounts, extensions] = await Promise.all([
         getSite(api, siteId, siteFeatureFlagPrefix),
         getAccounts(api),
-        getIntegrations({ siteId, testOpts, offline, accountId, token, featureFlags, extensionApiBaseUrl, mode }),
+        getExtensions({ siteId, testOpts, offline, accountId, token, featureFlags, extensionApiBaseUrl, mode }),
     ]);
+    // TODO(ndhoule): Investigate, but at this point, I'm fairly sure this is the default for all
+    // sites. If so, we can remove this conditional and always query for environment variables.
     if (siteInfo.use_envelope) {
         const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId, context });
         siteInfo.build_settings.env = envelope;
     }
-    return { siteInfo, accounts, integrations };
+    return { siteInfo, accounts, extensions };
 };
 const getSite = async function (api, siteId, siteFeatureFlagPrefix) {
     if (siteId === undefined) {
         return {};
     }
     try {
-        const site = await api.getSite({ siteId, feature_flags: siteFeatureFlagPrefix });
+        const site = await api.getSite({
+            // @ts-expect-error: Internal parameter that instructs the API to include all the site's
+            // feature flags in the response.
+            feature_flags: siteFeatureFlagPrefix,
+            siteId,
+        });
         return { ...site, id: siteId };
     }
-    catch (error) {
-        throwUserError(`Failed retrieving site data for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
+    catch (err) {
+        return throwUserError(`Failed retrieving site data for site ${siteId}: ${err.message}. ${ERROR_CALL_TO_ACTION}`);
     }
 };
 const getAccounts = async function (api) {
@@ -67,7 +79,27 @@ const getAccounts = async function (api) {
         return throwUserError(`Failed retrieving user account: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
     }
 };
-export const getIntegrations = async function ({ siteId, accountId, testOpts, offline, token, featureFlags, extensionApiBaseUrl, mode, }) {
+const ExtensionResponseSchema = z.array(z.object({
+    // ndhoule: The `author` and `extension_token` fields are not sent by the .../safe endpoint;
+    // we're normalizing them to empty values here to preserve...uh, whatever backward compatibility
+    // this is supposed to offer.
+    //
+    // At this point, I'm unsure if modern `@netlify/config` callers can end up in the .../safe
+    // codepath. This would be bad: extension-injected build hooks are far removed from this code
+    // path and have no way of knowing whether or not a specific consumer is in this legacy code
+    // path. They might call the Netlify API expecting to have an API token available to them when
+    // they really don't. For the time being, I've added instrumentation to Jigsaw to help us figure
+    // out if this is dead code or actually supports current users.
+    author: z.string().optional().default(undefined),
+    extension_token: z.string().optional().default(undefined),
+    has_build: z.boolean(),
+    name: z.string(),
+    slug: z.string(),
+    version: z.string(),
+    // Returned by API, but unused. Leaving this here for the sake of documentation.
+    // has_connector: z.boolean(),
+}));
+export const getExtensions = async function ({ siteId, accountId, testOpts, offline, token, featureFlags, extensionApiBaseUrl, mode, }) {
     if (!siteId || offline) {
         return [];
     }
@@ -76,14 +108,14 @@ export const getIntegrations = async function ({ siteId, accountId, testOpts, of
     // TODO(kh): I am adding this purely for local staging development.
     // We should remove this once we have fixed https://github.com/netlify/cli/blob/b5a5c7525edd28925c5c2e3e5f0f00c4261eaba5/src/lib/build.ts#L125
     let host = originalHost;
-    // If there is a host, we use it to fetch the integrations
+    // If there is a host, we use it to fetch the extensions
     // we check if the host is staging or production and set the host accordingly,
     // sadly necessary because of https://github.com/netlify/cli/blob/b5a5c7525edd28925c5c2e3e5f0f00c4261eaba5/src/lib/build.ts#L125
     if (originalHost) {
-        if (originalHost?.includes(NETLIFY_API_STAGING_BASE_URL)) {
+        if (originalHost?.includes(NETLIFY_API_STAGING_HOSTNAME)) {
             host = EXTENSION_API_STAGING_BASE_URL;
         }
-        else if (originalHost?.includes(NETLIFY_API_BASE_URL)) {
+        else if (originalHost?.includes(NETLIFY_API_HOSTNAME)) {
             host = EXTENSION_API_BASE_URL;
         }
         else {
@@ -99,30 +131,21 @@ export const getIntegrations = async function ({ siteId, accountId, testOpts, of
     const url = accountId
         ? `${baseUrl}team/${accountId}/integrations/installations/meta/${siteId}`
         : `${baseUrl}site/${siteId}/integrations/safe`;
+    const headers = new Headers({
+        'Netlify-Config-Mode': mode,
+        'User-Agent': `Netlify Config (mode:${mode}) / ${ROOT_PACKAGE_JSON.version}`,
+    });
+    if (sendBuildBotTokenToJigsaw && token) {
+        headers.set('Netlify-SDK-Build-Bot-Token', token);
+    }
     try {
-        const requestOptions = {};
-        // This is used to identify where the request is coming from
-        requestOptions.headers = {
-            'netlify-config-mode': mode,
-        };
-        if (sendBuildBotTokenToJigsaw && token) {
-            requestOptions.headers = {
-                ...requestOptions.headers,
-                'netlify-sdk-build-bot-token': token,
-            };
-        }
-        const response = await fetch(url, requestOptions);
-        if (!response.ok) {
-            throw new Error(`Unexpected status code ${response.status} from fetching extensions`);
+        const res = await fetch(url, { headers });
+        if (res.status !== 200) {
+            throw new Error(`Unexpected status code ${res.status} from fetching extensions`);
         }
-        const bodyText = await response.text();
-        if (bodyText === '') {
-            return [];
-        }
-        const integrations = await JSON.parse(bodyText);
-        return Array.isArray(integrations) ? integrations : [];
+        return ExtensionResponseSchema.parse(await res.json());
     }
-    catch (error) {
-        return throwUserError(`Failed retrieving extensions for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
+    catch (err) {
+        return throwUserError(`Failed retrieving extensions for site ${siteId}: ${err instanceof Error ? err.message : 'unknown error'}. ${ERROR_CALL_TO_ACTION}`);
     }
 };

package/lib/env/envelope.js

@@ -3,6 +3,7 @@ export const getEnvelope = async function ({ api, accountId, siteId, context, })
         return {};
     }
     try {
+        // TODO(ndhoule): The api client now has types; remove this type assertion to any and fix errors
         const environmentVariables = await api.getEnvVars({ accountId, siteId, context_name: context });
         const sortedEnvVarsFromContext = environmentVariables
             .sort((left, right) => (left.key.toLowerCase() < right.key.toLowerCase() ? -1 : 1))
@@ -19,6 +20,8 @@ export const getEnvelope = async function ({ api, accountId, siteId, context, })
         return sortedEnvVarsFromContext;
     }
     catch {
+        // TODO(ndhoule): We should probably not quietly fail to retrieve environment variables: This
+        // will produce confusingly inconsistent builds.
         return {};
     }
 };

package/lib/events.d.ts

@@ -1,2 +1,2 @@
-export const EVENTS: string[];
-export const DEV_EVENTS: string[];
+export declare const EVENTS: string[];
+export declare const DEV_EVENTS: string[];

package/lib/extensions.d.ts

@@ -0,0 +1,52 @@
+import { type Extension } from './api/site_info.js';
+export declare const NETLIFY_API_STAGING_HOSTNAME = "api-staging.netlify.com";
+export declare const NETLIFY_API_HOSTNAME = "api.netlify.com";
+export declare const EXTENSION_API_BASE_URL = "https://api.netlifysdk.com";
+export declare const EXTENSION_API_STAGING_BASE_URL = "https://api-staging.netlifysdk.com";
+export type MergeExtensionsOptions = {
+    /**
+     * Extensions loaded via the Netlify API. These are extensions enabled
+     */
+    apiExtensions: Extension[];
+    /**
+     * Development extensions loaded via the build target's netlify.toml file. Only used when the
+     * build context is set to `dev` (e.g. when `netlify build` is run with `--context=dev`).
+     */
+    configExtensions?: {
+        name: string;
+        dev?: {
+            path: string;
+            force_run_in_build?: boolean;
+        };
+    }[];
+    /**
+     * A path to the build target's build directory. We use this in dev mode to resolve non-absolute
+     * build plugin paths.
+     */
+    buildDir: string;
+    /**
+     * The current build context, set e.g. via `netlify build --context=<context>`.
+     */
+    context: string;
+};
+export type ExtensionWithDev = Extension & {
+    buildPlugin: {
+        origin: 'local' | 'remote';
+        packageURL: URL;
+    } | null;
+    dev?: {
+        path: string;
+        force_run_in_build?: boolean;
+    } | null;
+};
+/**
+ * normalizeAndMergeExtensions accepts several lists of extensions configured for the current build
+ * target, normalizes them to compensate for some differences between the various APIs we load this
+ * data from (one of two API endpoints and the user's config file), and merges them into a single
+ * list.
+ *
+ * Note that it merges extension data provided by the config file (configExtensions) only when
+ * context=dev. When it does so, config file data will be merged into any available API data, giving
+ * a preference to config file data.
+ */
+export declare const normalizeAndMergeExtensions: ({ apiExtensions, buildDir, configExtensions, context, }: MergeExtensionsOptions) => ExtensionWithDev[];

package/lib/extensions.js

@@ -0,0 +1,91 @@
+import path from 'node:path';
+import { throwUserError } from './error.js';
+export const NETLIFY_API_STAGING_HOSTNAME = 'api-staging.netlify.com';
+export const NETLIFY_API_HOSTNAME = 'api.netlify.com';
+export const EXTENSION_API_BASE_URL = 'https://api.netlifysdk.com';
+export const EXTENSION_API_STAGING_BASE_URL = 'https://api-staging.netlifysdk.com';
+/**
+ * normalizeAndMergeExtensions accepts several lists of extensions configured for the current build
+ * target, normalizes them to compensate for some differences between the various APIs we load this
+ * data from (one of two API endpoints and the user's config file), and merges them into a single
+ * list.
+ *
+ * Note that it merges extension data provided by the config file (configExtensions) only when
+ * context=dev. When it does so, config file data will be merged into any available API data, giving
+ * a preference to config file data.
+ */
+export const normalizeAndMergeExtensions = ({ apiExtensions, buildDir, configExtensions = [], context, }) => {
+    const apiExtensionsBySlug = new Map(apiExtensions.map((extension) => [
+        extension.slug,
+        {
+            ...extension,
+            buildPlugin: extension.has_build
+                ? { origin: 'remote', packageURL: new URL('/packages/buildhooks.tgz', extension.version) }
+                : null,
+            dev: null,
+        },
+    ]));
+    const configExtensionsBySlug = new Map(
+    // Only use configuration-file data in development mode
+    (context === 'dev' ? configExtensions : []).map((extension) => {
+        let buildPluginPackageURL = null;
+        if (extension.dev?.path) {
+            let resolvedPath = path.isAbsolute(extension.dev.path)
+                ? extension.dev.path
+                : path.resolve(buildDir, extension.dev.path);
+            const normalizedExtname = path.extname(resolvedPath).toLowerCase();
+            // If the user has specified a path to an extension directory rather than to a tarball
+            // package, interpret this as a shortcut for "the default Netlify Extension build plugin
+            // artifact path, please."
+            //
+            // This sort of emulates SDK v1/2/3 behavior, and is an effort at making extension dev mode
+            // friendlier to use. We can feel free to revisit this chocie at a later date.
+            if (normalizedExtname === '') {
+                resolvedPath = path.join(resolvedPath, '.ntli/site/static/packages/buildhooks.tgz');
+            }
+            buildPluginPackageURL = new URL(`file://${resolvedPath}`);
+        }
+        return [
+            extension.name,
+            // Normalize dev extensions to a similar shape as an API extension
+            {
+                author: undefined,
+                dev: extension.dev,
+                extension_token: undefined,
+                has_build: buildPluginPackageURL !== null,
+                name: extension.name,
+                slug: extension.name,
+                version: undefined,
+                buildPlugin: buildPluginPackageURL !== null ? { origin: 'local', packageURL: buildPluginPackageURL } : null,
+            },
+        ];
+    }));
+    // Merge API and configuration file metadata together by merging development metadata onto API
+    // metadata.
+    //
+    // Explicitly allow the configuration file to reference an extension that doesn't yet exist in the
+    // API so users can test their build hooks without publishing the extension first.
+    const mergedExtensions = [...new Set([...apiExtensionsBySlug.keys(), ...configExtensionsBySlug.keys()])]
+        .map((slug) => [apiExtensionsBySlug.get(slug), configExtensionsBySlug.get(slug)])
+        .map(([apiExtension, configExtension]) => {
+        return {
+            author: configExtension?.author ?? apiExtension?.author ?? '',
+            buildPlugin: configExtension?.buildPlugin ?? apiExtension?.buildPlugin ?? null,
+            dev: configExtension?.dev,
+            extension_token: configExtension?.extension_token ?? apiExtension?.extension_token ?? '',
+            has_build: configExtension?.has_build ?? apiExtension?.has_build ?? false,
+            name: configExtension?.name ?? apiExtension?.name ?? '',
+            slug: configExtension?.slug ?? apiExtension?.slug ?? '',
+            version: configExtension?.version ?? apiExtension?.version ?? '',
+        };
+    });
+    for (const extension of mergedExtensions) {
+        if (extension.buildPlugin !== null) {
+            const normalizedExtname = path.extname(extension.buildPlugin.packageURL.toString()).toLowerCase();
+            if (normalizedExtname !== '.tgz') {
+                throwUserError(`Extension ${extension.slug} contains unexpected build plugin URL: '${extension.buildPlugin.packageURL.toString()}'. Build plugin URLs must end in '.tgz'.`);
+            }
+        }
+    }
+    return mergedExtensions;
+};

package/lib/log/logger.js

@@ -1,5 +1,7 @@
 import figures from 'figures';
-import { serializeObject } from '../../lib/log/serialize.js';
+// FIXME: This error will go away once this file is converted to TypeScript.
+// eslint-disable-next-line n/no-missing-import
+import { serializeObject } from './serialize.js';
 import { THEME } from './theme.js';
 export const logsAreBuffered = (logs) => {
     return logs !== undefined && 'stdout' in logs;

package/lib/main.d.ts

@@ -1,4 +1,5 @@
 import { type MinimalAccount } from './api/site_info.js';
+import { type ExtensionWithDev } from './extensions.js';
 export type Config = {
     accounts: MinimalAccount[] | undefined;
     api: any;
@@ -9,7 +10,7 @@ export type Config = {
     context: any;
     env: any;
     headersPath: any;
-    integrations: any;
+    integrations: ExtensionWithDev[];
     logs: any;
     redirectsPath: any;
     repositoryRoot: any;

package/lib/main.js

@@ -9,7 +9,7 @@ import { getEnv } from './env/main.js';
 import { resolveConfigPaths } from './files.js';
 import { getHeadersPath, addHeaders } from './headers.js';
 import { getInlineConfig } from './inline_config.js';
-import { EXTENSION_API_BASE_URL, EXTENSION_API_STAGING_BASE_URL, mergeIntegrations, NETLIFY_API_STAGING_BASE_URL, } from './integrations.js';
+import { EXTENSION_API_BASE_URL, EXTENSION_API_STAGING_BASE_URL, NETLIFY_API_STAGING_HOSTNAME, normalizeAndMergeExtensions, } from './extensions.js';
 import { logResult } from './log/main.js';
 import { mergeConfigs } from './merge.js';
 import { normalizeBeforeConfigMerge, normalizeAfterConfigMerge } from './merge_normalize.js';
@@ -36,16 +36,16 @@ export const resolveConfig = async function (opts) {
         return parsedCachedConfig;
     }
     // TODO(kh): remove this mapping and get the extensionApiHost from the opts
-    const extensionApiBaseUrl = host?.includes(NETLIFY_API_STAGING_BASE_URL)
+    const extensionApiBaseUrl = host?.includes(NETLIFY_API_STAGING_HOSTNAME)
         ? EXTENSION_API_STAGING_BASE_URL
         : EXTENSION_API_BASE_URL;
     const { config: configOpt, defaultConfig, inlineConfig, configMutations, cwd, context, repositoryRoot, base, branch, siteId, accountId, deployId, buildId, baseRelDir, mode, debug, logs, featureFlags, } = await normalizeOpts(optsA);
-    let { siteInfo, accounts, integrations } = parsedCachedConfig || {};
+    let { siteInfo, accounts, integrations: extensions } = parsedCachedConfig || {};
     // If we have cached site info, we don't need to fetch it again
-    const useCachedSiteInfo = Boolean(featureFlags?.use_cached_site_info && siteInfo && accounts && integrations);
+    const useCachedSiteInfo = Boolean(featureFlags?.use_cached_site_info && siteInfo && accounts && extensions);
     // I'm adding some debug logging to see if the logic is working as expected
     if (featureFlags?.use_cached_site_info_logging) {
-        console.log('Checking site information', { useCachedSiteInfo, siteInfo, accounts, integrations });
+        console.log('Checking site information', { useCachedSiteInfo, siteInfo, accounts, extensions });
     }
     if (!useCachedSiteInfo) {
         const updatedSiteInfo = await getSiteInfo({
@@ -63,7 +63,7 @@ export const resolveConfig = async function (opts) {
         });
         siteInfo = updatedSiteInfo.siteInfo;
         accounts = updatedSiteInfo.accounts;
-        integrations = updatedSiteInfo.integrations;
+        extensions = updatedSiteInfo.extensions;
     }
     const { defaultConfig: defaultConfigA, baseRelDir: baseRelDirA } = parseDefaultConfig({
         defaultConfig,
@@ -102,9 +102,9 @@ export const resolveConfig = async function (opts) {
     });
     // @todo Remove in the next major version.
     const configA = addLegacyFunctionsDirectory(config);
-    const updatedIntegrations = await handleAutoInstallExtensions({
+    const updatedExtensions = await handleAutoInstallExtensions({
         featureFlags,
-        integrations,
+        extensions,
         siteId,
         accountId,
         token,
@@ -115,14 +115,15 @@ export const resolveConfig = async function (opts) {
         mode,
         debug,
     });
-    const mergedIntegrations = await mergeIntegrations({
-        apiIntegrations: updatedIntegrations,
-        configIntegrations: configA.integrations,
-        context: context,
+    const mergedExtensions = normalizeAndMergeExtensions({
+        apiExtensions: updatedExtensions,
+        configExtensions: configA.integrations,
+        buildDir,
+        context,
     });
     const result = {
         siteInfo,
-        integrations: mergedIntegrations,
+        integrations: mergedExtensions,
         accounts,
         env,
         configPath,

package/lib/utils/extensions/auto-install-extensions.d.ts

@@ -1,4 +1,4 @@
-import { type IntegrationResponse } from '../../types/api.js';
+import { type Extension } from '../../api/site_info.js';
 import { type ModeOption } from '../../types/options.js';
 interface AutoInstallOptions {
     featureFlags: any;
@@ -6,12 +6,12 @@ interface AutoInstallOptions {
     accountId: string;
     token: string;
     buildDir: string;
-    integrations: IntegrationResponse[];
+    extensions: Extension[];
     offline: boolean;
     testOpts: any;
     mode: ModeOption;
     extensionApiBaseUrl: string;
     debug?: boolean;
 }
-export declare function handleAutoInstallExtensions({ featureFlags, siteId, accountId, token, buildDir, integrations, offline, testOpts, mode, extensionApiBaseUrl, debug, }: AutoInstallOptions): Promise<IntegrationResponse[]>;
+export declare function handleAutoInstallExtensions({ featureFlags, siteId, accountId, token, buildDir, extensions, offline, testOpts, mode, extensionApiBaseUrl, debug, }: AutoInstallOptions): Promise<Extension[]>;
 export {};

package/lib/utils/extensions/auto-install-extensions.js

@@ -1,6 +1,6 @@
 import { createRequire } from 'module';
 import { join } from 'path';
-import { getIntegrations } from '../../api/site_info.js';
+import { getExtensions } from '../../api/site_info.js';
 import { fetchAutoInstallableExtensionsMeta, installExtension } from './utils.js';
 function getPackageJSON(directory) {
     try {
@@ -12,9 +12,9 @@ function getPackageJSON(directory) {
         return {};
     }
 }
-export async function handleAutoInstallExtensions({ featureFlags, siteId, accountId, token, buildDir, integrations, offline, testOpts = {}, mode, extensionApiBaseUrl, debug = false, }) {
+export async function handleAutoInstallExtensions({ featureFlags, siteId, accountId, token, buildDir, extensions, offline, testOpts = {}, mode, extensionApiBaseUrl, debug = false, }) {
     if (!featureFlags?.auto_install_required_extensions_v2) {
-        return integrations;
+        return extensions;
     }
     if (!accountId || !siteId || !token || !buildDir || offline) {
         const reason = !accountId
@@ -35,17 +35,17 @@ export async function handleAutoInstallExtensions({ featureFlags, siteId, accoun
                 mode,
             });
         }
-        return integrations;
+        return extensions;
     }
     try {
         const packageJson = getPackageJSON(buildDir);
         if (!packageJson?.dependencies ||
             typeof packageJson?.dependencies !== 'object' ||
             Object.keys(packageJson?.dependencies)?.length === 0) {
-            return integrations;
+            return extensions;
         }
         const autoInstallableExtensions = await fetchAutoInstallableExtensionsMeta();
-        const enabledExtensionSlugs = new Set((integrations ?? []).map(({ slug }) => slug));
+        const enabledExtensionSlugs = new Set((extensions ?? []).map(({ slug }) => slug));
         const extensionsToInstallCandidates = autoInstallableExtensions.filter(({ slug }) => !enabledExtensionSlugs.has(slug));
         const extensionsToInstall = extensionsToInstallCandidates.filter(({ packages }) => {
             for (const pkg of packages) {
@@ -56,7 +56,7 @@ export async function handleAutoInstallExtensions({ featureFlags, siteId, accoun
             return false;
         });
         if (extensionsToInstall.length === 0) {
-            return integrations;
+            return extensions;
         }
         const results = await Promise.all(extensionsToInstall.map(async (ext) => {
             console.log(`Installing extension "${ext.slug}" on team "${accountId}" required by package(s): "${ext.packages.join('",')}"`);
@@ -69,7 +69,7 @@ export async function handleAutoInstallExtensions({ featureFlags, siteId, accoun
             });
         }));
         if (results.length > 0 && results.some((result) => !result.error)) {
-            return getIntegrations({
+            return getExtensions({
                 siteId,
                 accountId,
                 testOpts,
@@ -80,10 +80,10 @@ export async function handleAutoInstallExtensions({ featureFlags, siteId, accoun
                 mode,
             });
         }
-        return integrations;
+        return extensions;
     }
     catch (error) {
         console.error(`Failed to auto install extension(s): ${error.message}`, error);
-        return integrations;
+        return extensions;
     }
 }

package/lib/utils/extensions/utils.js

@@ -1,4 +1,4 @@
-import { EXTENSION_API_BASE_URL } from '../../integrations.js';
+import { EXTENSION_API_BASE_URL } from '../../extensions.js';
 import { ROOT_PACKAGE_JSON } from '../json.js';
 export const installExtension = async ({ netlifyToken, accountId, slug, hostSiteUrl, extensionInstallationSource, }) => {
     const userAgent = `Netlify Config (mode:${extensionInstallationSource}) / ${ROOT_PACKAGE_JSON.version}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/config",
-  "version": "23.2.0",
+  "version": "24.0.0",
   "description": "Netlify config module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -81,7 +81,8 @@
     "tomlify-j0.4": "^3.0.0",
     "validate-npm-package-name": "^5.0.0",
     "yaml": "^2.8.0",
-    "yargs": "^17.6.0"
+    "yargs": "^17.6.0",
+    "zod": "^4.0.5"
   },
   "devDependencies": {
     "@types/node": "^18.19.111",
@@ -95,5 +96,5 @@
   "engines": {
     "node": ">=18.14.0"
   },
-  "gitHead": "243d65788aca4867c78403ac15c267f76feb6c00"
+  "gitHead": "5100d463cb9b606b91a6a9b5c3fbe9c143716701"
 }

package/lib/integrations.d.ts

@@ -1,19 +0,0 @@
-import { IntegrationResponse } from './types/api.js';
-import { Integration } from './types/integrations.js';
-export declare const NETLIFY_API_STAGING_BASE_URL = "api-staging.netlify.com";
-export declare const NETLIFY_API_BASE_URL = "api.netlify.com";
-export declare const EXTENSION_API_BASE_URL = "https://api.netlifysdk.com";
-export declare const EXTENSION_API_STAGING_BASE_URL = "https://api-staging.netlifysdk.com";
-type MergeIntegrationsOpts = {
-    configIntegrations?: {
-        name: string;
-        dev?: {
-            path: string;
-            force_run_in_build?: boolean;
-        };
-    }[];
-    apiIntegrations: IntegrationResponse[];
-    context: string;
-};
-export declare const mergeIntegrations: ({ configIntegrations, apiIntegrations, context, }: MergeIntegrationsOpts) => Promise<Integration[]>;
-export {};

package/lib/integrations.js

@@ -1,33 +0,0 @@
-export const NETLIFY_API_STAGING_BASE_URL = 'api-staging.netlify.com';
-export const NETLIFY_API_BASE_URL = 'api.netlify.com';
-export const EXTENSION_API_BASE_URL = 'https://api.netlifysdk.com';
-export const EXTENSION_API_STAGING_BASE_URL = 'https://api-staging.netlifysdk.com';
-export const mergeIntegrations = async function ({ configIntegrations = [], apiIntegrations, context, }) {
-    // Include all API integrations, unless they have a `dev` property and we are in the `dev` context
-    const resolvedApiIntegrations = apiIntegrations.filter((integration) => !configIntegrations.some((configIntegration) => configIntegration.name === integration.slug &&
-        typeof configIntegration.dev !== 'undefined' &&
-        context === 'dev'));
-    // For integrations loaded from the TOML, we will use the local reference in the `dev` context,
-    // otherwise we will fetch from the API and match the slug
-    const resolvedConfigIntegrations = configIntegrations
-        .filter((configIntegration) => apiIntegrations.every((apiIntegration) => apiIntegration.slug !== configIntegration.name) ||
-        ('dev' in configIntegration && context === 'dev'))
-        .map((configIntegration) => {
-        const apiIntegration = apiIntegrations.find((apiIntegration) => apiIntegration.slug === configIntegration.name);
-        if (configIntegration.dev && context === 'dev') {
-            return {
-                slug: configIntegration.name,
-                dev: configIntegration.dev,
-                // TODO(kh): has_build should become irrelevant soon as we are only returning extensions that have a build event handler.
-                has_build: apiIntegration?.has_build ?? configIntegration.dev?.force_run_in_build ?? false,
-                ...apiIntegration,
-            };
-        }
-        if (!apiIntegration) {
-            return undefined;
-        }
-        return apiIntegration;
-    })
-        .filter((i) => typeof i !== 'undefined');
-    return [...resolvedApiIntegrations, ...resolvedConfigIntegrations];
-};

package/lib/types/api.d.ts

@@ -1,5 +0,0 @@
-export type IntegrationResponse = {
-    slug: string;
-    version: string;
-    has_build: boolean;
-};

package/lib/types/api.js

@@ -1 +0,0 @@
-export {};

package/lib/types/integrations.d.ts

@@ -1,9 +0,0 @@
-export type Integration = {
-    slug: string;
-    version?: string;
-    has_build?: boolean;
-    dev?: {
-        path: string;
-    };
-    author?: string;
-};

package/lib/types/integrations.js

@@ -1 +0,0 @@
-export {};