feat: retrieve integration meta data from new endpoint

packages/config/src/api/site_info.ts

@@ -14,7 +14,6 @@ type GetSiteInfoOpts = {
   offline?: boolean
   api?: NetlifyAPI
   context?: string
-  featureFlags?: Record<string, boolean>
   testOpts?: TestOptions
 }
 /**
@@ -37,30 +36,58 @@ export const getSiteInfo = async function ({
 }: GetSiteInfoOpts) {
   const { env: testEnv = false } = testOpts
 
-  if (api === undefined || mode === 'buildbot' || testEnv) {
+  if (api === undefined || testEnv || offline) {
     const siteInfo = siteId === undefined ? {} : { id: siteId }
 
-    const integrations = mode === 'buildbot' && !offline ? await getIntegrations({ siteId, testOpts, offline }) : []
-
-    return { siteInfo, accounts: [], addons: [], integrations }
+    return { siteInfo, accounts: [], addons: [], integrations: [] }
   }
 
-  const promises = [
-    getSite(api, siteId, siteFeatureFlagPrefix),
-    getAccounts(api),
-    getAddons(api, siteId),
-    getIntegrations({ siteId, testOpts, offline }),
-  ]
+  const siteInfo = await getSite(api, siteId, siteFeatureFlagPrefix)
+  const featureFlags = siteInfo.feature_flags
 
-  const [siteInfo, accounts, addons, integrations] = await Promise.all(promises)
+  const useV1Endpoint = !featureFlags?.cli_integration_installations_meta
 
-  if (siteInfo.use_envelope) {
-    const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId, context })
+  if (useV1Endpoint) {
+    if (mode === 'buildbot') {
+      const siteInfo = siteId === undefined ? {} : { id: siteId }
 
-    siteInfo.build_settings.env = envelope
-  }
+      const integrations = await getIntegrations({ siteId, testOpts, offline, featureFlags })
+
+      return { siteInfo, accounts: [], addons: [], integrations }
+    }
+
+    const promises = [
+      getAccounts(api),
+      getAddons(api, siteId),
+      getIntegrations({ siteId, testOpts, offline, featureFlags }),
+    ]
+
+    const [accounts, addons, integrations] = await Promise.all(promises)
+
+    if (siteInfo.use_envelope) {
+      const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId, context })
+
+      siteInfo.build_settings.env = envelope
+    }
+
+    return { siteInfo, accounts, addons, integrations }
+  } else {
+    const promises = [
+      getAccounts(api),
+      getAddons(api, siteId),
+      getIntegrations({ siteId, testOpts, offline, accountId: siteInfo.account_id, featureFlags }),
+    ]
 
-  return { siteInfo, accounts, addons, integrations }
+    const [accounts, addons, integrations] = await Promise.all(promises)
+
+    if (siteInfo.use_envelope) {
+      const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId, context })
+
+      siteInfo.build_settings.env = envelope
+    }
+
+    return { siteInfo, accounts, addons, integrations }
+  }
 }
 
 const getSite = async function (api: NetlifyAPI, siteId: string, siteFeatureFlagPrefix: string | null = null) {
@@ -73,6 +100,8 @@ const getSite = async function (api: NetlifyAPI, siteId: string, siteFeatureFlag
     return { ...site, id: siteId }
   } catch (error) {
     throwUserError(`Failed retrieving site data for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`)
+    // Added to satisfy TypeScript only an object can be returned
+    return { id: siteId }
   }
 }
 
@@ -82,6 +111,8 @@ const getAccounts = async function (api: NetlifyAPI) {
     return Array.isArray(accounts) ? accounts : []
   } catch (error) {
     throwUserError(`Failed retrieving user account: ${error.message}. ${ERROR_CALL_TO_ACTION}`)
+    // Added to satisfy TypeScript only an array can be returned
+    return []
   }
 }
 
@@ -95,19 +126,25 @@ const getAddons = async function (api: NetlifyAPI, siteId: string) {
     return Array.isArray(addons) ? addons : []
   } catch (error) {
     throwUserError(`Failed retrieving addons for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`)
+    // Added to satisfy TypeScript only an array can be returned
+    return []
   }
 }
 
 type GetIntegrationsOpts = {
   siteId?: string
+  accountId?: string
   testOpts: TestOptions
   offline: boolean
+  featureFlags?: Record<string, boolean>
 }
 
 const getIntegrations = async function ({
   siteId,
+  accountId,
   testOpts,
   offline,
+  featureFlags,
 }: GetIntegrationsOpts): Promise<IntegrationResponse[]> {
   if (!siteId || offline) {
     return []
@@ -117,13 +154,20 @@ const getIntegrations = async function ({
 
   const baseUrl = new URL(host ? `http://${host}` : `https://api.netlifysdk.com`)
 
+  const useV1Endpoint = !featureFlags?.cli_integration_installations_meta
+
+  const url = useV1Endpoint
+    ? `${baseUrl}site/${siteId}/integrations/safe`
+    : `${baseUrl}team/${accountId}/integrations/installations/meta`
+
   try {
-    const response = await fetch(`${baseUrl}site/${siteId}/integrations/safe`)
+    const response = await fetch(url)
 
     const integrations = await response.json()
     return Array.isArray(integrations) ? integrations : []
   } catch (error) {
-    // for now, we'll just ignore errors, as this is early days
+    // Integrations should not block the build if they fail to load
+    // TODO: We should consider blocking the build as integrations are a critical part of the build process
     return []
   }
 }

packages/config/src/main.ts

@@ -73,7 +73,6 @@ export const resolveConfig = async function (opts) {
     mode,
     offline,
     siteFeatureFlagPrefix,
-    featureFlags,
     testOpts,
   })
 

packages/config/tests/api/tests.js

@@ -26,11 +26,37 @@ const SITE_INTEGRATIONS_RESPONSE = {
   ],
 }
 
+const TEAM_INSTALLATIONS_META_RESPONSE = {
+  path: '/team/account1/integrations/installations/meta',
+  response: [
+    {
+      slug: 'test',
+      version: 'so-cool',
+      has_build: true,
+    },
+  ],
+}
+
 const SITE_INTEGRATIONS_EMPTY_RESPONSE = {
   path: '/site/test/integrations/safe',
   response: [],
 }
 
+const siteInfoWithFeatureFlag = (flag) => {
+  return {
+    path: SITE_INFO_PATH,
+    response: {
+      ssl_url: 'test',
+      name: 'test-name',
+      build_settings: { repo_url: 'test' },
+      account_id: 'account1',
+      feature_flags: {
+        [flag]: true,
+      },
+    },
+  }
+}
+
 const SITE_INFO_BUILD_SETTINGS = {
   path: SITE_INFO_PATH,
   response: {
@@ -307,36 +333,114 @@ test('In integration dev mode, integration specified in config is returned and b
   t.assert(config.integrations[0].version === undefined)
 })
 
-test('Integrations are returned if feature flag is true, mode buildbot', async (t) => {
+test('Integrations are not returned if offline', async (t) => {
   const { output } = await new Fixture('./fixtures/base')
     .withFlags({
+      offline: true,
       siteId: 'test',
       mode: 'buildbot',
     })
     .runConfigServer([SITE_INTEGRATIONS_RESPONSE, FETCH_INTEGRATIONS_EMPTY_RESPONSE])
 
   const config = JSON.parse(output)
 
+  t.assert(config.integrations)
+  t.assert(config.integrations.length === 0)
+})
+
+test('Integrations are not returned if no api', async (t) => {
+  const { output } = await new Fixture('./fixtures/base')
+    .withFlags({
+      siteId: 'test',
+      mode: 'buildbot',
+    })
+    .runConfigServer([SITE_INTEGRATIONS_RESPONSE, FETCH_INTEGRATIONS_EMPTY_RESPONSE])
+
+  const config = JSON.parse(output)
+
+  t.assert(config.integrations)
+  t.assert(config.integrations.length === 0)
+})
+
+test('Integrations are returned if feature flag is false and mode is buildbot', async (t) => {
+  const { output } = await new Fixture('./fixtures/base')
+    .withFlags({
+      siteId: 'test',
+      mode: 'buildbot',
+      token: 'test',
+    })
+    .runConfigServer([SITE_INFO_DATA, SITE_INTEGRATIONS_RESPONSE, FETCH_INTEGRATIONS_EMPTY_RESPONSE])
+
+  const config = JSON.parse(output)
+
   t.assert(config.integrations)
   t.assert(config.integrations.length === 1)
   t.assert(config.integrations[0].slug === 'test')
   t.assert(config.integrations[0].version === 'so-cool')
   t.assert(config.integrations[0].has_build === true)
 })
 
-test('Integrations are not returned if offline', async (t) => {
+test('Integrations are returned if feature flag is false and mode is dev', async (t) => {
+  const { output } = await new Fixture('./fixtures/base')
+    .withFlags({
+      siteId: 'test',
+      mode: 'dev',
+      token: 'test',
+    })
+    .runConfigServer([SITE_INFO_DATA, SITE_INTEGRATIONS_RESPONSE, FETCH_INTEGRATIONS_EMPTY_RESPONSE])
+
+  const config = JSON.parse(output)
+
+  t.assert(config.integrations)
+  t.assert(config.integrations.length === 1)
+  t.assert(config.integrations[0].slug === 'test')
+  t.assert(config.integrations[0].version === 'so-cool')
+  t.assert(config.integrations[0].has_build === true)
+})
+
+// new tests
+test('Integrations are returned if flag is true for site and mode is buildbot', async (t) => {
   const { output } = await new Fixture('./fixtures/base')
     .withFlags({
-      offline: true,
       siteId: 'test',
       mode: 'buildbot',
+      token: 'test',
     })
-    .runConfigServer([SITE_INTEGRATIONS_RESPONSE, FETCH_INTEGRATIONS_EMPTY_RESPONSE])
+    .runConfigServer([
+      siteInfoWithFeatureFlag('cli_integration_installations_meta'),
+      TEAM_INSTALLATIONS_META_RESPONSE,
+      FETCH_INTEGRATIONS_EMPTY_RESPONSE,
+    ])
 
   const config = JSON.parse(output)
 
   t.assert(config.integrations)
-  t.assert(config.integrations.length === 0)
+  t.assert(config.integrations.length === 1)
+  t.assert(config.integrations[0].slug === 'test')
+  t.assert(config.integrations[0].version === 'so-cool')
+  t.assert(config.integrations[0].has_build === true)
+})
+
+test('Integrations are returned if flag is true for site and mode is dev', async (t) => {
+  const { output } = await new Fixture('./fixtures/base')
+    .withFlags({
+      siteId: 'test',
+      mode: 'dev',
+      token: 'test',
+    })
+    .runConfigServer([
+      siteInfoWithFeatureFlag('cli_integration_installations_meta'),
+      TEAM_INSTALLATIONS_META_RESPONSE,
+      FETCH_INTEGRATIONS_EMPTY_RESPONSE,
+    ])
+
+  const config = JSON.parse(output)
+
+  t.assert(config.integrations)
+  t.assert(config.integrations.length === 1)
+  t.assert(config.integrations[0].slug === 'test')
+  t.assert(config.integrations[0].version === 'so-cool')
+  t.assert(config.integrations[0].has_build === true)
 })
 
 test('baseRelDir is true if build.base is overridden', async (t) => {