@netlify/config 20.8.0 → 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/edge_functions.js

@@ -1,9 +1,11 @@
 import { isString, validProperties } from './validate/helpers.js';
 const cacheValues = ['manual', 'off'];
+const methodValues = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'];
+const isMethod = (value) => typeof value === 'string' && methodValues.includes(value.toUpperCase());
 export const validations = [
     {
         property: 'edge_functions.*',
-        ...validProperties(['path', 'excludedPath', 'pattern', 'excludedPattern', 'function', 'cache'], []),
+        ...validProperties(['path', 'excludedPath', 'pattern', 'excludedPattern', 'function', 'cache', 'method'], []),
         example: () => ({ edge_functions: [{ path: '/hello', function: 'hello' }] }),
     },
     {
@@ -76,4 +78,10 @@ export const validations = [
         message: `must be one of: ${cacheValues.join(', ')}`,
         example: () => ({ edge_functions: [{ cache: cacheValues[0], path: '/hello', function: 'hello' }] }),
     },
+    {
+        property: 'edge_functions.*.method',
+        check: (value) => isMethod(value) || (Array.isArray(value) && value.length !== 0 && value.every(isMethod)),
+        message: `must be one of or array of: ${methodValues.join(', ')}`,
+        example: () => ({ edge_functions: [{ method: ['PUT', 'DELETE'], path: '/hello', function: 'hello' }] }),
+    },
 ];

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/path.js

@@ -6,6 +6,7 @@ const FILENAME = 'netlify.toml';
 /**
  * Configuration location can be:
  * - a local path with the --config CLI flag
+ * - a `netlify.*` file in the `repositoryRoot/{base}/{packagePath}`
  * - a `netlify.*` file in the `repositoryRoot/{base}`
  * - a `netlify.*` file in the `repositoryRoot`
  * - a `netlify.*` file in the current directory or any parent

package/lib/types/integrations.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/config",
-  "version": "20.8.0",
+  "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": "0c6f5c014958f692559ea720c38415a0e63b7522"
+  "gitHead": "5521b954cc7944141d095434e39cce2af3d3ccaf"
 }