feat(config): handle auto installable extensions (#6284)

* feat: handle auto installable extensions

* feature flag "auto_install_required_extensions"
* fetch list of auto installable extensions from jigsaw
"/meta/auto-installable"
* using "@netlify/build-info" for project.getPackageJSON()
* detect matching installed packages to determine which extensions to
auto install
* automatically install the extension on the team

* fix: rename requiredExt -> installableExt

Just renaming

* fix: remove console log

remove console log opts

* chore: remove unnecessary netlifyToken variables

just using opts.token directly now

* feat: remove @netlify/build-info and just read package json with fs

build-info had some deps that broke things for older versions of node
like 14~

* fix: addressing PR feedback

* use require to load package.json instead of accessing file directly
* reduce additional API calls made on each build down to 1 by re-using
what we already have
* if extensions do get installed, update the apiIntegrations and pass to
mergeIntegrations so it is included in the final result
* remove unnecessary getJigsawToken call

Author: Caleb Barnes

packages/config/src/api/site_info.ts

@@ -138,7 +138,7 @@ type GetIntegrationsOpts = {
   mode: ModeOption
 }
 
-const getIntegrations = async function ({
+export const getIntegrations = async function ({
   siteId,
   accountId,
   testOpts,

packages/config/src/main.ts

@@ -23,6 +23,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'
 
 export type Config = {
   accounts: MinimalAccount[] | undefined
@@ -169,8 +170,22 @@ export const resolveConfig = async function (opts): Promise<Config> {
   // @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,
   })
@@ -192,6 +207,7 @@ export const resolveConfig = async function (opts): Promise<Config> {
     api,
     logs,
   }
+
   logResult(result, { logs, debug })
   return result
 }

packages/config/src/utils/extensions/auto-install-extensions.ts

@@ -0,0 +1,100 @@
+import { createRequire } from 'module'
+import { join } from 'path'
+
+import { getIntegrations } from '../../api/site_info.js'
+import { type IntegrationResponse } from '../../types/api.js'
+import { type ModeOption } from '../../types/options.js'
+
+import { fetchAutoInstallableExtensionsMeta, installExtension } from './utils.js'
+
+function getPackageJSON(directory: string) {
+  const require = createRequire(join(directory, 'package.json'))
+  return require('./package.json')
+}
+
+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 async function handleAutoInstallExtensions({
+  featureFlags,
+  siteId,
+  accountId,
+  token,
+  cwd,
+  accounts,
+  integrations,
+  offline,
+  testOpts = {},
+  mode,
+  extensionApiBaseUrl,
+}: AutoInstallOptions) {
+  if (!featureFlags?.auto_install_required_extensions || !accountId || !siteId || !token || !cwd || offline) {
+    return integrations
+  }
+  const account = accounts?.find((account: any) => 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
+  }
+}

packages/config/src/utils/extensions/utils.ts

@@ -0,0 +1,75 @@
+import { EXTENSION_API_BASE_URL } from '../../integrations.js'
+
+export type InstallExtensionResult =
+  | {
+      slug: string
+      error: null
+    }
+  | {
+      slug: string
+      error: {
+        code: string
+        message: string
+      }
+    }
+
+export const installExtension = async ({
+  netlifyToken,
+  accountId,
+  slug,
+  hostSiteUrl,
+}: {
+  netlifyToken: string
+  accountId: string
+  slug: string
+  hostSiteUrl: string
+}): Promise<InstallExtensionResult> => {
+  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,
+  }
+}
+
+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 async function fetchAutoInstallableExtensionsMeta(): Promise<AutoInstallableExtensionMeta[]> {
+  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 as AutoInstallableExtensionMeta[]
+}