@netlify/config 22.1.0 → 22.2.0

package/lib/api/site_info.d.ts

@@ -40,4 +40,15 @@ export type MinimalAccount = {
     type_slug: string;
     members_count: number;
 };
+type GetIntegrationsOpts = {
+    siteId?: string;
+    accountId?: string;
+    testOpts: TestOptions;
+    offline: boolean;
+    token?: string;
+    featureFlags?: Record<string, boolean>;
+    extensionApiBaseUrl: string;
+    mode: ModeOption;
+};
+export declare const getIntegrations: ({ siteId, accountId, testOpts, offline, token, featureFlags, extensionApiBaseUrl, mode, }: GetIntegrationsOpts) => Promise<IntegrationResponse[]>;
 export {};

package/lib/api/site_info.js

@@ -68,7 +68,7 @@ const getAccounts = async function (api) {
         return throwUserError(`Failed retrieving user account: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
     }
 };
-const getIntegrations = async function ({ siteId, accountId, testOpts, offline, token, featureFlags, extensionApiBaseUrl, mode, }) {
+export const getIntegrations = async function ({ siteId, accountId, testOpts, offline, token, featureFlags, extensionApiBaseUrl, mode, }) {
     if (!siteId || offline) {
         return [];
     }

package/lib/main.js

@@ -18,6 +18,7 @@ import { UI_ORIGIN, CONFIG_ORIGIN, INLINE_ORIGIN } from './origin.js';
 import { parseConfig } from './parse.js';
 import { getConfigPath } from './path.js';
 import { getRedirectsPath, addRedirects } from './redirects.js';
+import { handleAutoInstallExtensions } from './utils/extensions/auto-install-extensions.js';
 /**
  * Load the configuration file.
  * Takes an optional configuration file path as input and return the resolved
@@ -101,8 +102,21 @@ export const resolveConfig = async function (opts) {
     });
     // @todo Remove in the next major version.
     const configA = addLegacyFunctionsDirectory(config);
+    const updatedIntegrations = await handleAutoInstallExtensions({
+        featureFlags,
+        accounts,
+        integrations,
+        siteId,
+        accountId,
+        token,
+        cwd,
+        extensionApiBaseUrl,
+        testOpts,
+        offline,
+        mode,
+    });
     const mergedIntegrations = await mergeIntegrations({
-        apiIntegrations: integrations,
+        apiIntegrations: updatedIntegrations,
         configIntegrations: configA.integrations,
         context: context,
     });

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

@@ -0,0 +1,17 @@
+import { type IntegrationResponse } from '../../types/api.js';
+import { type ModeOption } from '../../types/options.js';
+interface AutoInstallOptions {
+    featureFlags: any;
+    siteId: string;
+    accountId: string;
+    token: string;
+    cwd: string;
+    accounts: any;
+    integrations: IntegrationResponse[];
+    offline: boolean;
+    testOpts: any;
+    mode: ModeOption;
+    extensionApiBaseUrl: string;
+}
+export declare function handleAutoInstallExtensions({ featureFlags, siteId, accountId, token, cwd, accounts, integrations, offline, testOpts, mode, extensionApiBaseUrl, }: AutoInstallOptions): Promise<IntegrationResponse[]>;
+export {};

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

@@ -0,0 +1,58 @@
+import { createRequire } from 'module';
+import { join } from 'path';
+import { getIntegrations } from '../../api/site_info.js';
+import { fetchAutoInstallableExtensionsMeta, installExtension } from './utils.js';
+function getPackageJSON(directory) {
+    const require = createRequire(join(directory, 'package.json'));
+    return require('./package.json');
+}
+export async function handleAutoInstallExtensions({ featureFlags, siteId, accountId, token, cwd, accounts, integrations, offline, testOpts = {}, mode, extensionApiBaseUrl, }) {
+    if (!featureFlags?.auto_install_required_extensions || !accountId || !siteId || !token || !cwd || offline) {
+        return integrations;
+    }
+    const account = accounts?.find((account) => account.id === accountId);
+    if (!account) {
+        return integrations;
+    }
+    try {
+        const packageJson = getPackageJSON(cwd);
+        if (!packageJson?.dependencies ||
+            typeof packageJson?.dependencies !== 'object' ||
+            Object.keys(packageJson?.dependencies)?.length === 0) {
+            return integrations;
+        }
+        const autoInstallableExtensions = await fetchAutoInstallableExtensionsMeta();
+        const extensionsToInstall = autoInstallableExtensions.filter((ext) => {
+            return !integrations?.some((integration) => integration.slug === ext.slug);
+        });
+        if (extensionsToInstall.length === 0) {
+            return integrations;
+        }
+        const results = await Promise.all(extensionsToInstall.map(async (ext) => {
+            console.log(`Installing extension "${ext.slug}" on team "${account.name}" required by package(s): "${ext.packages.join('",')}"`);
+            return installExtension({
+                accountId,
+                netlifyToken: token,
+                slug: ext.slug,
+                hostSiteUrl: ext.hostSiteUrl,
+            });
+        }));
+        if (results.length > 0 && results.some((result) => !result.error)) {
+            return getIntegrations({
+                siteId,
+                accountId,
+                testOpts,
+                offline,
+                token,
+                featureFlags,
+                extensionApiBaseUrl,
+                mode,
+            });
+        }
+        return integrations;
+    }
+    catch (error) {
+        console.error(`Failed to auto install extension(s): ${error.message}`, error);
+        return integrations;
+    }
+}

package/lib/utils/extensions/utils.d.ts

@@ -0,0 +1,31 @@
+export type InstallExtensionResult = {
+    slug: string;
+    error: null;
+} | {
+    slug: string;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export declare const installExtension: ({ netlifyToken, accountId, slug, hostSiteUrl, }: {
+    netlifyToken: string;
+    accountId: string;
+    slug: string;
+    hostSiteUrl: string;
+}) => Promise<InstallExtensionResult>;
+type AutoInstallableExtensionMeta = {
+    slug: string;
+    hostSiteUrl: string;
+    packages: string[];
+};
+/**
+ * Fetches the list of extensions from Jigsaw that declare associated packages.
+ * Used to determine which extensions should be auto-installed based on the packages
+ * present in the package.json (e.g., if an extension lists '@netlify/neon',
+ * and that package exists in package.json, the extension will be auto-installed).
+ *
+ * @returns Array of extensions with their associated packages
+ */
+export declare function fetchAutoInstallableExtensionsMeta(): Promise<AutoInstallableExtensionMeta[]>;
+export {};

package/lib/utils/extensions/utils.js

@@ -0,0 +1,44 @@
+import { EXTENSION_API_BASE_URL } from '../../integrations.js';
+export const installExtension = async ({ netlifyToken, accountId, slug, hostSiteUrl, }) => {
+    const extensionOnInstallUrl = new URL('/.netlify/functions/handler/on-install', hostSiteUrl);
+    const installedResponse = await fetch(extensionOnInstallUrl, {
+        method: 'POST',
+        body: JSON.stringify({
+            teamId: accountId,
+        }),
+        headers: {
+            'netlify-token': netlifyToken,
+        },
+    });
+    if (!installedResponse.ok && installedResponse.status !== 409) {
+        const text = await installedResponse.text();
+        return {
+            slug,
+            error: {
+                code: installedResponse.status.toString(),
+                message: text,
+            },
+        };
+    }
+    return {
+        slug,
+        error: null,
+    };
+};
+/**
+ * Fetches the list of extensions from Jigsaw that declare associated packages.
+ * Used to determine which extensions should be auto-installed based on the packages
+ * present in the package.json (e.g., if an extension lists '@netlify/neon',
+ * and that package exists in package.json, the extension will be auto-installed).
+ *
+ * @returns Array of extensions with their associated packages
+ */
+export async function fetchAutoInstallableExtensionsMeta() {
+    const url = new URL(`/meta/auto-installable`, process.env.EXTENSION_API_BASE_URL ?? EXTENSION_API_BASE_URL);
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+        throw new Error(`Failed to fetch extensions meta`);
+    }
+    const data = await response.json();
+    return data;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/config",
-  "version": "22.1.0",
+  "version": "22.2.0",
   "description": "Netlify config module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -95,5 +95,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "82cf0f22248692da58acd77d8b7ba0e10ddcd1fe"
+  "gitHead": "03eae326c598d4d31b28fe8f20038c5d9508f772"
 }