@netlify/config 20.14.1 → 20.15.1

package/lib/api/site_info.d.ts

@@ -2,8 +2,8 @@ import { NetlifyAPI } from 'netlify';
 import { ModeOption, TestOptions } from '../types/options.js';
 type GetSiteInfoOpts = {
     siteId: string;
+    accountId?: string;
     mode: ModeOption;
-    siteFeatureFlagPrefix: string;
     offline?: boolean;
     api?: NetlifyAPI;
     context?: string;
@@ -19,7 +19,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, mode, siteFeatureFlagPrefix, context, offline, testOpts, }: GetSiteInfoOpts) => Promise<{
+export declare const getSiteInfo: ({ api, siteId, accountId, mode, context, offline, testOpts, featureFlags, }: GetSiteInfoOpts) => Promise<{
     siteInfo: any;
     accounts: any;
     addons: any;

package/lib/api/site_info.js

@@ -11,15 +11,37 @@ import { ERROR_CALL_TO_ACTION } from '../log/messages.js';
  * Silently ignore API errors. For example the network connection might be down,
  * but local builds should still work regardless.
  */
-export const getSiteInfo = async function ({ api, siteId, mode, siteFeatureFlagPrefix, context, offline = false, testOpts = {}, }) {
+export const getSiteInfo = async function ({ api, siteId, accountId, mode, context, offline = false, testOpts = {}, featureFlags = {}, }) {
     const { env: testEnv = false } = testOpts;
+    const useV2Endpoint = !!accountId && featureFlags.cli_integration_installations_meta;
+    if (useV2Endpoint) {
+        if (api === undefined || mode === 'buildbot' || testEnv) {
+            const siteInfo = siteId === undefined ? {} : { id: siteId };
+            const integrations = mode === 'buildbot' && !offline
+                ? await getIntegrations({ siteId, testOpts, offline, useV2Endpoint, accountId })
+                : [];
+            return { siteInfo, accounts: [], addons: [], integrations };
+        }
+        const promises = [
+            getSite(api, siteId),
+            getAccounts(api),
+            getAddons(api, siteId),
+            getIntegrations({ siteId, testOpts, offline, useV2Endpoint, accountId }),
+        ];
+        const [siteInfo, accounts, addons, integrations] = await Promise.all(promises);
+        if (siteInfo.use_envelope) {
+            const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId, context });
+            siteInfo.build_settings.env = envelope;
+        }
+        return { siteInfo, accounts, addons, integrations };
+    }
     if (api === undefined || mode === 'buildbot' || testEnv) {
         const siteInfo = siteId === undefined ? {} : { id: siteId };
         const integrations = mode === 'buildbot' && !offline ? await getIntegrations({ siteId, testOpts, offline }) : [];
         return { siteInfo, accounts: [], addons: [], integrations };
     }
     const promises = [
-        getSite(api, siteId, siteFeatureFlagPrefix),
+        getSite(api, siteId),
         getAccounts(api),
         getAddons(api, siteId),
         getIntegrations({ siteId, testOpts, offline }),
@@ -31,12 +53,12 @@ export const getSiteInfo = async function ({ api, siteId, mode, siteFeatureFlagP
     }
     return { siteInfo, accounts, addons, integrations };
 };
-const getSite = async function (api, siteId, siteFeatureFlagPrefix = null) {
+const getSite = async function (api, siteId) {
     if (siteId === undefined) {
         return {};
     }
     try {
-        const site = await api.getSite({ siteId, feature_flags: siteFeatureFlagPrefix });
+        const site = await api.getSite({ siteId });
         return { ...site, id: siteId };
     }
     catch (error) {
@@ -64,19 +86,24 @@ const getAddons = async function (api, siteId) {
         throwUserError(`Failed retrieving addons for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
     }
 };
-const getIntegrations = async function ({ siteId, testOpts, offline, }) {
+const getIntegrations = async function ({ siteId, accountId, testOpts, offline, useV2Endpoint, }) {
     if (!siteId || offline) {
         return [];
     }
     const { host } = testOpts;
     const baseUrl = new URL(host ? `http://${host}` : `https://api.netlifysdk.com`);
+    const url = useV2Endpoint
+        ? `${baseUrl}team/${accountId}/integrations/installations/meta`
+        : `${baseUrl}site/${siteId}/integrations/safe`;
     try {
-        const response = await fetch(`${baseUrl}site/${siteId}/integrations/safe`);
+        const response = await fetch(url);
         const integrations = await response.json();
         return Array.isArray(integrations) ? integrations : [];
     }
     catch (error) {
-        // for now, we'll just ignore errors, as this is early days
+        // Integrations should not block the build if they fail to load
+        // TODO: We should consider blocking the build as integrations are a critical part of the build process
+        // https://linear.app/netlify/issue/CT-1214/implement-strategy-in-builds-to-deal-with-integrations-that-we-fail-to
         return [];
     }
 };

package/lib/bin/flags.d.ts

@@ -16,6 +16,7 @@ export declare const parseFlags: () => Partial<{
     scheme: unknown;
     pathPrefix: unknown;
     siteId: unknown;
+    accountId: unknown;
     context: unknown;
     branch: unknown;
     baseRelDir: unknown;

package/lib/bin/flags.js

@@ -118,6 +118,10 @@ The NETLIFY_AUTH_TOKEN environment variable can be used as well.`,
         string: true,
         describe: `Netlify Site ID.`,
     },
+    accountId: {
+        string: true,
+        describe: 'Netlify Account ID. This will only be available in buildbot mode.',
+    },
     context: {
         string: true,
         describe: `Build context.

package/lib/main.js

@@ -24,21 +24,21 @@ import { getRedirectsPath, addRedirects } from './redirects.js';
  * `config` together with related properties such as the `configPath`.
  */
 export const resolveConfig = async function (opts) {
-    const { cachedConfig, cachedConfigPath, host, scheme, packagePath, pathPrefix, testOpts, token, offline, siteFeatureFlagPrefix, ...optsA } = addDefaultOpts(opts);
+    const { cachedConfig, cachedConfigPath, host, scheme, packagePath, pathPrefix, testOpts, token, offline, ...optsA } = addDefaultOpts(opts);
     // `api` is not JSON-serializable, so we cannot cache it inside `cachedConfig`
     const api = getApiClient({ token, offline, host, scheme, pathPrefix, testOpts });
     const parsedCachedConfig = await getCachedConfig({ cachedConfig, cachedConfigPath, token, api });
     if (parsedCachedConfig !== undefined) {
         return parsedCachedConfig;
     }
-    const { config: configOpt, defaultConfig, inlineConfig, configMutations, cwd, context, repositoryRoot, base, branch, siteId, deployId, buildId, baseRelDir, mode, debug, logs, featureFlags, } = await normalizeOpts(optsA);
+    const { config: configOpt, defaultConfig, inlineConfig, configMutations, cwd, context, repositoryRoot, base, branch, siteId, accountId, deployId, buildId, baseRelDir, mode, debug, logs, featureFlags, } = await normalizeOpts(optsA);
     const { siteInfo, accounts, addons, integrations } = await getSiteInfo({
         api,
         context,
         siteId,
+        accountId,
         mode,
         offline,
-        siteFeatureFlagPrefix,
         featureFlags,
         testOpts,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/config",
-  "version": "20.14.1",
+  "version": "20.15.1",
   "description": "Netlify config module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -72,7 +72,7 @@
     "is-plain-obj": "^4.0.0",
     "js-yaml": "^4.0.0",
     "map-obj": "^5.0.0",
-    "netlify": "^13.1.17",
+    "netlify": "^13.1.18",
     "netlify-headers-parser": "^7.1.4",
     "netlify-redirect-parser": "^14.3.0",
     "node-fetch": "^3.3.1",
@@ -95,5 +95,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "c99f5dcf3198d3a279ee06d7e42c204405cd977a"
+  "gitHead": "aa96e910e165bde1a46101bcf73702818d008214"
 }