@netlify/config 21.0.5 → 21.0.7

package/lib/api/site_info.d.ts

@@ -1,4 +1,5 @@
 import { NetlifyAPI } from 'netlify';
+import { IntegrationResponse } from '../types/api.js';
 import { ModeOption, TestOptions } from '../types/options.js';
 type GetSiteInfoOpts = {
     siteId: string;
@@ -24,8 +25,20 @@ type GetSiteInfoOpts = {
  */
 export declare const getSiteInfo: ({ api, siteId, accountId, mode, context, offline, testOpts, siteFeatureFlagPrefix, token, featureFlags, extensionApiBaseUrl, }: GetSiteInfoOpts) => Promise<{
     siteInfo: any;
-    accounts: any;
-    addons: any;
-    integrations: any;
+    accounts: MinimalAccount[];
+    addons: any[] | undefined;
+    integrations: IntegrationResponse[];
 }>;
+export type MinimalAccount = {
+    id: string;
+    name: string;
+    slug: string;
+    default: boolean;
+    team_logo_url: string | null;
+    on_pro_trial: boolean;
+    organization_id: string | null;
+    type_name: string;
+    type_slug: string;
+    members_count: number;
+};
 export {};

package/lib/api/site_info.js

@@ -1,6 +1,7 @@
 import fetch from 'node-fetch';
 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 { ERROR_CALL_TO_ACTION } from '../log/messages.js';
 /**
  * Retrieve Netlify Site information, if available.
@@ -20,17 +21,25 @@ export const getSiteInfo = async function ({ api, siteId, accountId, mode, conte
         if (accountId !== undefined)
             siteInfo.account_id = accountId;
         const integrations = mode === 'buildbot' && !offline
-            ? await getIntegrations({ siteId, testOpts, offline, accountId, token, featureFlags, extensionApiBaseUrl })
+            ? await getIntegrations({
+                siteId,
+                testOpts,
+                offline,
+                accountId,
+                token,
+                featureFlags,
+                extensionApiBaseUrl,
+                mode,
+            })
             : [];
         return { siteInfo, accounts: [], addons: [], integrations };
     }
-    const promises = [
+    const [siteInfo, accounts, addons, integrations] = await Promise.all([
         getSite(api, siteId, siteFeatureFlagPrefix),
         getAccounts(api),
         getAddons(api, siteId),
-        getIntegrations({ siteId, testOpts, offline, accountId, token, featureFlags, extensionApiBaseUrl }),
-    ];
-    const [siteInfo, accounts, addons, integrations] = await Promise.all(promises);
+        getIntegrations({ siteId, testOpts, offline, accountId, token, featureFlags, extensionApiBaseUrl, mode }),
+    ]);
     if (siteInfo.use_envelope) {
         const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId, context });
         siteInfo.build_settings.env = envelope;
@@ -51,11 +60,13 @@ const getSite = async function (api, siteId, siteFeatureFlagPrefix) {
 };
 const getAccounts = async function (api) {
     try {
-        const accounts = await api.listAccountsForUser();
+        const accounts = (await api.listAccountsForUser(
+        // @ts-expect-error(ndhoule): This is an unpublished, internal querystring parameter
+        { minimal: 'true' }));
         return Array.isArray(accounts) ? accounts : [];
     }
     catch (error) {
-        throwUserError(`Failed retrieving user account: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
+        return throwUserError(`Failed retrieving user account: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
     }
 };
 const getAddons = async function (api, siteId) {
@@ -70,25 +81,47 @@ const getAddons = async function (api, siteId) {
         throwUserError(`Failed retrieving addons for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
     }
 };
-const getIntegrations = async function ({ siteId, accountId, testOpts, offline, token, featureFlags, extensionApiBaseUrl, }) {
+const getIntegrations = async function ({ siteId, accountId, testOpts, offline, token, featureFlags, extensionApiBaseUrl, mode, }) {
     if (!siteId || offline) {
         return [];
     }
     const sendBuildBotTokenToJigsaw = featureFlags?.send_build_bot_token_to_jigsaw;
-    const { host, setBaseUrl } = testOpts;
+    const { host: originalHost, setBaseUrl } = testOpts;
+    // 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
+    // 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)) {
+            host = EXTENSION_API_STAGING_BASE_URL;
+        }
+        else if (originalHost?.includes(NETLIFY_API_BASE_URL)) {
+            host = EXTENSION_API_BASE_URL;
+        }
+        else {
+            host = `http://${originalHost}`;
+        }
+    }
+    const baseUrl = new URL(host ?? extensionApiBaseUrl);
     // We only use this for testing
     if (host && setBaseUrl) {
         setBaseUrl(extensionApiBaseUrl);
     }
-    const baseUrl = new URL(host ? `http://${host}` : extensionApiBaseUrl);
     // if accountId isn't present, use safe v1 endpoint
     const url = accountId
         ? `${baseUrl}team/${accountId}/integrations/installations/meta/${siteId}`
         : `${baseUrl}site/${siteId}/integrations/safe`;
     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,
             };
         }

package/lib/integrations.d.ts

@@ -1,7 +1,7 @@
 import { IntegrationResponse } from './types/api.js';
 import { Integration } from './types/integrations.js';
-import { TestOptions } from './types/options.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 = {
@@ -14,9 +14,6 @@ type MergeIntegrationsOpts = {
     }[];
     apiIntegrations: IntegrationResponse[];
     context: string;
-    testOpts?: TestOptions;
-    offline: boolean;
-    extensionApiBaseUrl: string;
 };
-export declare const mergeIntegrations: ({ configIntegrations, apiIntegrations, context, testOpts, offline, extensionApiBaseUrl, }: MergeIntegrationsOpts) => Promise<Integration[]>;
+export declare const mergeIntegrations: ({ configIntegrations, apiIntegrations, context, }: MergeIntegrationsOpts) => Promise<Integration[]>;
 export {};

package/lib/integrations.js

@@ -1,9 +1,8 @@
-import { getAvailableIntegrations } from './api/integrations.js';
 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, testOpts = {}, offline, extensionApiBaseUrl, }) {
-    const availableIntegrations = await getAvailableIntegrations({ testOpts, offline, extensionApiBaseUrl });
+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' &&
@@ -14,19 +13,20 @@ export const mergeIntegrations = async function ({ configIntegrations = [], apiI
         .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') {
-            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,
+                // 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,
             };
         }
-        const integration = availableIntegrations.find((availableIntegration) => availableIntegration.slug === configIntegration.name);
-        if (!integration) {
+        if (!apiIntegration) {
             return undefined;
         }
-        return { slug: integration.slug, version: integration.hostSiteUrl, has_build: !!integration.hasBuild };
+        return apiIntegration;
     })
         .filter((i) => typeof i !== 'undefined');
     return [...resolvedApiIntegrations, ...resolvedConfigIntegrations];

package/lib/main.d.ts

@@ -1,6 +1,25 @@
+import { type MinimalAccount } from './api/site_info.js';
+export type Config = {
+    accounts: MinimalAccount[] | undefined;
+    addons: any;
+    api: any;
+    branch: any;
+    buildDir: any;
+    config: any;
+    configPath: any;
+    context: any;
+    env: any;
+    headersPath: any;
+    integrations: any;
+    logs: any;
+    redirectsPath: any;
+    repositoryRoot: any;
+    siteInfo: any;
+    token: any;
+};
 /**
  * Load the configuration file.
  * Takes an optional configuration file path as input and return the resolved
  * `config` together with related properties such as the `configPath`.
  */
-export declare const resolveConfig: (opts: any) => Promise<any>;
+export declare const resolveConfig: (opts: any) => Promise<Config>;

package/lib/main.js

@@ -35,7 +35,9 @@ export const resolveConfig = async function (opts) {
         return parsedCachedConfig;
     }
     // TODO(kh): remove this mapping and get the extensionApiHost from the opts
-    const extensionApiBaseUrl = host === NETLIFY_API_STAGING_BASE_URL ? EXTENSION_API_STAGING_BASE_URL : EXTENSION_API_BASE_URL;
+    const extensionApiBaseUrl = host?.includes(NETLIFY_API_STAGING_BASE_URL)
+        ? 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, addons, integrations } = parsedCachedConfig || {};
     // If we have cached site info, we don't need to fetch it again
@@ -105,9 +107,6 @@ export const resolveConfig = async function (opts) {
         apiIntegrations: integrations,
         configIntegrations: configA.integrations,
         context: context,
-        testOpts,
-        offline,
-        extensionApiBaseUrl,
     });
     const result = {
         siteInfo,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/config",
-  "version": "21.0.5",
+  "version": "21.0.7",
   "description": "Netlify config module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -95,5 +95,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "0e4628f57a0a7d02594b5070074445a4ff69b809"
+  "gitHead": "8d10878db3be9cfefe3162fd155c76595aba045e"
 }

package/lib/api/integrations.d.ts

@@ -1,13 +0,0 @@
-import { TestOptions } from '../types/options.js';
-type AvailableIntegration = {
-    slug: string;
-    hostSiteUrl: string;
-    hasBuild?: boolean;
-};
-type GetAvailableIntegrationsOpts = {
-    testOpts: TestOptions;
-    offline: boolean;
-    extensionApiBaseUrl: string;
-};
-export declare const getAvailableIntegrations: ({ testOpts, offline, extensionApiBaseUrl, }: GetAvailableIntegrationsOpts) => Promise<AvailableIntegration[]>;
-export {};

package/lib/api/integrations.js

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