@netlify/config 20.8.1 → 20.9.0

package/lib/api/integrations.js

@@ -0,0 +1,16 @@
+import fetch from 'node-fetch';
+export const getAvailableIntegrations = async function ({ testOpts, }) {
+    const { host } = testOpts;
+    const baseUrl = new URL(host ? `http://${host}/` : `https://api.netlifysdk.com/`);
+    try {
+        const response = await fetch(`${baseUrl}integrations`);
+        if (response.ok) {
+            const integrations = (await response.json());
+            return Array.isArray(integrations) ? integrations : [];
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+};

package/lib/api/site_info.js

@@ -11,19 +11,20 @@ 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, offline = false, featureFlags = {}, testOpts = {}, }) {
+export const getSiteInfo = async function ({ api, siteId, mode, siteFeatureFlagPrefix, offline = false, testOpts = {}, }) {
     const { env: testEnv = false } = testOpts;
-    const fetchIntegrations = featureFlags.buildbot_fetch_integrations;
     if (api === undefined || mode === 'buildbot' || testEnv) {
         const siteInfo = siteId === undefined ? {} : { id: siteId };
-        const integrations = fetchIntegrations && mode === 'buildbot' && !offline ? await getIntegrations({ siteId, testOpts }) : [];
+        const integrations = mode === 'buildbot' && !offline ? await getIntegrations({ siteId, testOpts }) : [];
         return { siteInfo, accounts: [], addons: [], integrations };
     }
-    const promises = [getSite(api, siteId, siteFeatureFlagPrefix), getAccounts(api), getAddons(api, siteId)];
-    if (fetchIntegrations) {
-        promises.push(getIntegrations({ siteId, testOpts }));
-    }
-    const [siteInfo, accounts, addons, integrations = []] = await Promise.all(promises);
+    const promises = [
+        getSite(api, siteId, siteFeatureFlagPrefix),
+        getAccounts(api),
+        getAddons(api, siteId),
+        getIntegrations({ siteId, testOpts }),
+    ];
+    const [siteInfo, accounts, addons, integrations] = await Promise.all(promises);
     if (siteInfo.use_envelope) {
         const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId });
         siteInfo.build_settings.env = envelope;

package/lib/integrations.js

@@ -0,0 +1,34 @@
+import { getAvailableIntegrations } from './api/integrations.js';
+export const mergeIntegrations = async function ({ configIntegrations = [], apiIntegrations, context, testOpts = {}, }) {
+    const availableIntegrations = await getAvailableIntegrations({ testOpts });
+    // 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) => {
+        if (configIntegration.dev && context === 'dev') {
+            const integrationInstance = apiIntegrations.find((apiIntegration) => apiIntegration.slug === configIntegration.name);
+            return {
+                slug: configIntegration.name,
+                dev: configIntegration.dev,
+                has_build: integrationInstance?.has_build ?? configIntegration.dev?.force_run_in_build ?? false,
+            };
+        }
+        const integration = availableIntegrations.find((availableIntegration) => availableIntegration.slug === configIntegration.name);
+        if (!integration) {
+            return undefined;
+        }
+        return {
+            slug: integration.slug,
+            version: integration.hostSiteUrl,
+            has_build: !!integration.hasBuild,
+        };
+    })
+        .filter((i) => typeof i !== 'undefined');
+    return [...resolvedApiIntegrations, ...resolvedConfigIntegrations];
+};

package/lib/main.js

@@ -9,6 +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 { mergeIntegrations } from './integrations.js';
 import { logResult } from './log/main.js';
 import { mergeConfigs } from './merge.js';
 import { normalizeBeforeConfigMerge, normalizeAfterConfigMerge } from './merge_normalize.js';
@@ -77,9 +78,15 @@ export const resolveConfig = async function (opts) {
     });
     // @todo Remove in the next major version.
     const configA = addLegacyFunctionsDirectory(config);
+    const mergedIntegrations = await mergeIntegrations({
+        apiIntegrations: integrations,
+        configIntegrations: configA.integrations,
+        context: context,
+        testOpts,
+    });
     const result = {
         siteInfo,
-        integrations,
+        integrations: mergedIntegrations,
         accounts,
         addons,
         env,

package/lib/types/integrations.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/config",
-  "version": "20.8.1",
+  "version": "20.9.0",
   "description": "Netlify config module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -94,5 +94,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "0eb6dbbfd00ba11941b1ef638811eded8a030a17"
+  "gitHead": "5521b954cc7944141d095434e39cce2af3d3ccaf"
 }