@netlify/build 27.18.5-rc → 27.18.5

package/src/steps/update_config.js

@@ -0,0 +1,93 @@
+import { isDeepStrictEqual } from 'util'
+
+import pFilter from 'p-filter'
+import { pathExists } from 'path-exists'
+
+import { resolveUpdatedConfig } from '../core/config.js'
+import { addErrorInfo } from '../error/info.js'
+import { logConfigOnUpdate } from '../log/messages/config.js'
+import { logConfigMutations } from '../log/messages/mutations.js'
+
+// If `netlifyConfig` was updated or `_redirects` was created, the configuration
+// is updated by calling `@netlify/config` again.
+export const updateNetlifyConfig = async function ({
+  configOpts,
+  netlifyConfig,
+  headersPath,
+  redirectsPath,
+  configMutations,
+  newConfigMutations,
+  configSideFiles,
+  errorParams,
+  logs,
+  debug,
+}) {
+  if (!(await shouldUpdateConfig({ newConfigMutations, configSideFiles, headersPath, redirectsPath }))) {
+    return { netlifyConfig, configMutations }
+  }
+
+  validateConfigMutations(newConfigMutations)
+  logConfigMutations(logs, newConfigMutations, debug)
+  const configMutationsA = [...configMutations, ...newConfigMutations]
+  const {
+    config: netlifyConfigA,
+    headersPath: headersPathA,
+    redirectsPath: redirectsPathA,
+  } = await resolveUpdatedConfig(configOpts, configMutationsA)
+  logConfigOnUpdate({ logs, netlifyConfig: netlifyConfigA, debug })
+  // eslint-disable-next-line fp/no-mutation,no-param-reassign
+  errorParams.netlifyConfig = netlifyConfigA
+  return {
+    netlifyConfig: netlifyConfigA,
+    configMutations: configMutationsA,
+    headersPath: headersPathA,
+    redirectsPath: redirectsPathA,
+  }
+}
+
+const shouldUpdateConfig = async function ({ newConfigMutations, configSideFiles, headersPath, redirectsPath }) {
+  return (
+    newConfigMutations.length !== 0 || (await haveConfigSideFilesChanged(configSideFiles, headersPath, redirectsPath))
+  )
+}
+
+// The configuration mostly depends on `netlify.toml` and UI build settings.
+// However, it also uses some additional optional side files like `_redirects`.
+// Those are often created by the build command. When those are created, we need
+// to update the configuration. We detect this by checking for file existence
+// before and after running plugins and the build command.
+const haveConfigSideFilesChanged = async function (configSideFiles, headersPath, redirectsPath) {
+  const newSideFiles = await listConfigSideFiles([headersPath, redirectsPath])
+  return !isDeepStrictEqual(newSideFiles, configSideFiles)
+}
+
+// List all the files used for configuration besides `netlify.toml`.
+// This is useful when applying configuration mutations since those files
+// sometimes have higher priority and should therefore be deleted in order to
+// apply any configuration update on `netlify.toml`.
+export const listConfigSideFiles = async function (sideFiles) {
+  const configSideFiles = await pFilter(sideFiles, pathExists)
+  // eslint-disable-next-line fp/no-mutating-methods
+  return configSideFiles.sort()
+}
+
+// Validate each new configuration change
+const validateConfigMutations = function (newConfigMutations) {
+  try {
+    newConfigMutations.forEach(validateConfigMutation)
+  } catch (error) {
+    addErrorInfo(error, { type: 'pluginValidation' })
+    throw error
+  }
+}
+
+// Triggered when calling `netlifyConfig.{key} = undefined | null`
+// We do not allow this because the back-end only receives mutations as a
+// `netlify.toml`, i.e. cannot apply property deletions since `undefined` is
+// not serializable in TOML.
+const validateConfigMutation = function ({ value, keysString }) {
+  if (value === undefined || value === null) {
+    throw new Error(`Setting "netlifyConfig.${keysString}" to ${value} is not allowed.
+Please set this property to a specific value instead.`)
+  }
+}

package/src/telemetry/main.js

@@ -0,0 +1,136 @@
+import { platform } from 'process'
+
+import got from 'got'
+import osName from 'os-name'
+
+import { addErrorInfo } from '../error/info.js'
+import { roundTimerToMillisecs } from '../time/measure.js'
+import { ROOT_PACKAGE_JSON } from '../utils/json.js'
+
+const DEFAULT_TELEMETRY_TIMEOUT = 1200
+const DEFAULT_TELEMETRY_CONFIG = {
+  origin: 'https://api.segment.io/v1',
+  writeKey: 'dWhlM1lYSlpNd1k5Uk9rcjFra2JSOEoybnRjZjl0YTI6',
+  timeout: DEFAULT_TELEMETRY_TIMEOUT,
+}
+
+// Send telemetry request when build completes
+export const trackBuildComplete = async function ({
+  deployId,
+  buildId,
+  status,
+  stepsCount,
+  pluginsOptions,
+  durationNs,
+  siteInfo,
+  telemetry,
+  userNodeVersion,
+  framework,
+  testOpts: { telemetryOrigin = DEFAULT_TELEMETRY_CONFIG.origin, telemetryTimeout = DEFAULT_TELEMETRY_CONFIG.timeout },
+}) {
+  if (!telemetry) {
+    return
+  }
+
+  try {
+    const payload = getPayload({
+      deployId,
+      buildId,
+      status,
+      stepsCount,
+      pluginsOptions,
+      durationNs,
+      siteInfo,
+      userNodeVersion,
+      framework,
+    })
+    await track({
+      payload,
+      config: { ...DEFAULT_TELEMETRY_CONFIG, origin: telemetryOrigin, timeout: telemetryTimeout },
+    })
+  } catch (error) {
+    addErrorInfo(error, { type: 'telemetry' })
+    throw error
+  }
+}
+
+// Send track HTTP request to telemetry.
+const track = async function ({ payload, config: { origin, writeKey, timeout } }) {
+  const url = `${origin}/track`
+  await got.post(url, {
+    json: payload,
+    timeout,
+    retry: 0,
+    headers: { Authorization: `Basic ${writeKey}` },
+  })
+}
+
+// Retrieve telemetry information
+// siteInfo can be empty if the build fails during the get config step
+const getPayload = function ({
+  deployId,
+  buildId,
+  status,
+  stepsCount,
+  pluginsOptions,
+  durationNs,
+  userNodeVersion,
+  siteInfo = {},
+  framework,
+}) {
+  return {
+    userId: 'buildbot_user',
+    event: 'build:ci_build_process_completed',
+    timestamp: Date.now(),
+    properties: {
+      deployId,
+      buildId,
+      status,
+      steps: stepsCount,
+      buildVersion: ROOT_PACKAGE_JSON.version,
+      // We're passing the node version set by the buildbot/user which will run the `build.command` and
+      // the `package.json`/locally defined plugins
+      nodeVersion: userNodeVersion,
+      osPlatform: OS_TYPES[platform],
+      osName: osName(),
+      framework,
+      siteId: siteInfo.id,
+      ...(pluginsOptions !== undefined && {
+        plugins: pluginsOptions.map(getPlugin),
+        pluginCount: pluginsOptions.length,
+      }),
+      ...(durationNs !== undefined && { duration: roundTimerToMillisecs(durationNs) }),
+    },
+  }
+}
+
+const OS_TYPES = {
+  linux: 'Linux',
+  darwin: 'MacOS',
+  win32: 'Windows',
+  android: 'Android',
+  sunos: 'SunOS',
+  aix: 'AIX',
+  freebsd: 'FreeBSD',
+  openbsd: 'OpenBSD',
+}
+
+const getPlugin = function ({
+  packageName,
+  origin,
+  loadedFrom,
+  nodeVersion,
+  pinnedVersion,
+  pluginPackageJson: { version } = {},
+}) {
+  const installType = getInstallType(origin, loadedFrom)
+  return { name: packageName, installType, nodeVersion, pinnedVersion, version }
+}
+
+const getInstallType = function (origin, loadedFrom) {
+  if (loadedFrom === 'auto_install') {
+    return origin === 'ui' ? 'ui' : 'netlify_toml'
+  }
+
+  return loadedFrom
+}

package/src/time/aggregate.js

@@ -0,0 +1,146 @@
+import { createTimer, TOP_PARENT_TAG } from './main.js'
+
+// Some timers are computed based on others:
+//   - `others` is `total` minus the other timers
+//   - `run_plugins` is the sum of all plugins
+//   - `run_netlify_build_per_type` aggregates timers but per system/plugin/user
+//   - each plugin timer is the sum of its event handlers
+export const addAggregatedTimers = function (timers) {
+  const timersA = addRunPluginsTimer(timers)
+  const timersB = addPluginTimers(timersA)
+  const timersC = addOthersTimers(timersB)
+  const timersD = addTypeTimers(timersC)
+  return timersD
+}
+
+// Having a `total` timer is redundant since the buildbot already measures this.
+// The buildbot measurement is better since it includes the time to load Node.
+// Instead, we only use `total` to measure what did not get `measureDuration()`.
+const addOthersTimers = function (timers) {
+  const totalTimer = timers.find(isTotalTimer)
+  const timersA = timers.filter((timer) => !isTotalTimer(timer))
+  const topTimers = timersA.filter(isTopTimer)
+  const othersTimer = createOthersTimer(topTimers, totalTimer)
+  return [...timersA, othersTimer]
+}
+
+const isTotalTimer = function ({ stageTag, parentTag }) {
+  return stageTag === 'total' && parentTag === 'build_site'
+}
+
+const createOthersTimer = function (topTimers, { durationNs: totalTimerDurationNs }) {
+  const topTimersDurationNs = computeTimersDuration(topTimers)
+  const otherTimersDurationNs = Math.max(0, totalTimerDurationNs - topTimersDurationNs)
+  const othersTimer = createTimer(OTHERS_STAGE_TAG, otherTimersDurationNs)
+  return othersTimer
+}
+
+const OTHERS_STAGE_TAG = 'others'
+
+// Measure the total time running plugins
+const addRunPluginsTimer = function (timers) {
+  const pluginsTimers = timers.filter(isPluginTimer)
+  return pluginsTimers.length === 0 ? timers : [...timers, createSumTimer(pluginsTimers, RUN_PLUGINS_STAGE_TAG)]
+}
+
+const RUN_PLUGINS_STAGE_TAG = 'run_plugins'
+
+// Retrieve one timer for each plugin, summing all its individual timers
+// (one per event handler)
+const addPluginTimers = function (timers) {
+  const timersA = timers.filter((timer) => !isCommunityPluginTimer(timer))
+  const pluginsTimers = timersA.filter(isPluginTimer)
+  if (pluginsTimers.length === 0) {
+    return timersA
+  }
+
+  const pluginPackages = getPluginPackages(pluginsTimers)
+  const wholePluginsTimers = pluginPackages.map((pluginPackage) => getWholePluginTimer(pluginPackage, pluginsTimers))
+  return [...timersA, ...wholePluginsTimers]
+}
+
+// We only measure plugins maintained by us, not community
+const isCommunityPluginTimer = function (timer) {
+  return isPluginTimer(timer) && !isNetlifyMaintainedPlugin(getPluginTimerPackage(timer))
+}
+
+const isNetlifyMaintainedPlugin = function (pluginPackage) {
+  return NETLIFY_MAINTAINED_PLUGINS.has(pluginPackage)
+}
+
+const NETLIFY_MAINTAINED_PLUGINS = new Set([
+  'netlify_plugin_gatsby_cache',
+  'netlify_plugin_sitemap',
+  'netlify_plugin_debug_cache',
+  'netlify_plugin_is_website_vulnerable',
+  'netlify_plugin_lighthouse',
+  'netlify_plugin_nextjs',
+  'netlify_plugin_gatsby',
+])
+
+const getPluginPackages = function (pluginsTimers) {
+  const pluginPackages = pluginsTimers.map(getPluginTimerPackage)
+  return [...new Set(pluginPackages)]
+}
+
+const getWholePluginTimer = function (pluginPackage, pluginsTimers) {
+  const pluginTimers = pluginsTimers.filter((pluginTimer) => getPluginTimerPackage(pluginTimer) === pluginPackage)
+  const wholePluginsTimer = createSumTimer(pluginTimers, pluginPackage, RUN_PLUGINS_STAGE_TAG)
+  return wholePluginsTimer
+}
+
+const getPluginTimerPackage = function ({ parentTag }) {
+  return parentTag
+}
+
+// Check if a timer relates to a Build plugin
+const isPluginTimer = function ({ category }) {
+  return category === 'pluginEvent'
+}
+
+// Reports total time depending on whether it was system, plugin or user
+const addTypeTimers = function (timers) {
+  const topTimers = timers.filter(isTopTimer)
+  const typeTimers = TYPE_TIMERS.map(({ name, stages }) => getTypeTimer(name, stages, topTimers)).filter(Boolean)
+  return [...timers, ...typeTimers]
+}
+
+const TYPE_TIMERS = [
+  { name: 'system', stages: ['resolve_config', 'get_plugins_options', 'start_plugins', 'others'] },
+  { name: 'plugin', stages: ['load_plugins', 'run_plugins'] },
+  { name: 'user', stages: ['build_command', 'functions_bundling', 'deploy_site'] },
+]
+
+const getTypeTimer = function (name, stages, topTimers) {
+  const topTimersA = topTimers.filter(({ stageTag }) => stages.includes(stageTag))
+
+  if (topTimersA.length === 0) {
+    return
+  }
+
+  const typeTimer = createSumTimer(topTimersA, name, 'run_netlify_build_per_type')
+  return typeTimer
+}
+
+const isTopTimer = function ({ parentTag }) {
+  return parentTag === TOP_PARENT_TAG
+}
+
+// Creates a timer that sums up the duration of several others
+const createSumTimer = function (timers, stageTag, parentTag) {
+  const durationNs = computeTimersDuration(timers)
+  const timer = createTimer(stageTag, durationNs, { parentTag })
+  return timer
+}
+
+const computeTimersDuration = function (timers) {
+  return timers.map(getTimerDuration).reduce(reduceSum, 0)
+}
+
+const getTimerDuration = function ({ durationNs }) {
+  return durationNs
+}
+
+const reduceSum = function (sum, number) {
+  return sum + number
+}

package/src/time/main.js

@@ -0,0 +1,48 @@
+import slugify from '@sindresorhus/slugify'
+import keepFuncProps from 'keep-func-props'
+
+import { startTimer, endTimer } from './measure.js'
+
+// Initialize the `timers` array
+export const initTimers = function () {
+  return []
+}
+
+// Wrap an async function to measure how long it takes.
+// The function must:
+//   - take a plain object as first argument. This must contain a `timers`.
+//   - return a plain object. This may or may not contain a modified `timers`.
+// The `durationNs` will be returned by the function. A new `timers` with the
+// additional duration timer will be returned as well.
+const kMeasureDuration = function (func, stageTag, { parentTag, category } = {}) {
+  return async function measuredFunc({ timers, ...opts }, ...args) {
+    const timerNs = startTimer()
+    const { timers: timersA = timers, ...returnObject } = await func({ timers, ...opts }, ...args)
+    const { tags = {} } = returnObject
+    const durationNs = endTimer(timerNs)
+    const timer = createTimer(stageTag, durationNs, { parentTag, category, tags })
+    const timersB = [...timersA, timer]
+    return { ...returnObject, timers: timersB, durationNs }
+  }
+}
+
+// Ensure the wrapped function `name` is not `anonymous` in stack traces
+export const measureDuration = keepFuncProps(kMeasureDuration)
+
+// Create a new object representing a completed timer
+export const createTimer = function (
+  stageTag,
+  durationNs,
+  { metricName = DEFAULT_METRIC_NAME, parentTag = TOP_PARENT_TAG, category, tags } = {},
+) {
+  return { metricName, stageTag, parentTag, durationNs, category, tags }
+}
+
+const DEFAULT_METRIC_NAME = 'buildbot.build.stage.duration'
+export const TOP_PARENT_TAG = 'run_netlify_build'
+
+// Make sure the timer name does not include special characters.
+// For example, the `packageName` of local plugins includes dots.
+export const normalizeTimerName = function (name) {
+  return slugify(name, { separator: '_' })
+}

package/src/time/measure.js

@@ -0,0 +1,22 @@
+import { hrtime } from 'process'
+
+// Starts a timer
+export const startTimer = function () {
+  return hrtime()
+}
+
+// Stops a timer
+export const endTimer = function ([startSecs, startNsecs]) {
+  const [endSecs, endNsecs] = hrtime()
+  const durationNs = (endSecs - startSecs) * NANOSECS_TO_SECS + endNsecs - startNsecs
+  return durationNs
+}
+
+// statsd expects milliseconds integers.
+// To prevent double rounding errors, rounding should only be applied once.
+export const roundTimerToMillisecs = function (durationNs) {
+  return Math.round(durationNs / NANOSECS_TO_MSECS)
+}
+
+const NANOSECS_TO_SECS = 1e9
+const NANOSECS_TO_MSECS = 1e6

package/src/time/report.js

@@ -0,0 +1,59 @@
+import { promisify } from 'util'
+
+import StatsdClient from 'statsd-client'
+
+import { addAggregatedTimers } from './aggregate.js'
+import { roundTimerToMillisecs } from './measure.js'
+
+// TODO: replace with `timers/promises` after dropping Node < 15.0.0
+const pSetTimeout = promisify(setTimeout)
+
+// Record the duration of a build phase, for monitoring.
+// Sends to statsd daemon.
+export const reportTimers = async function ({ timers, statsdOpts: { host, port }, framework }) {
+  if (host === undefined) {
+    return
+  }
+
+  const timersA = addAggregatedTimers(timers)
+  await sendTimers({ timers: timersA, host, port, framework })
+}
+
+const sendTimers = async function ({ timers, host, port, framework }) {
+  const client = await startClient(host, port)
+  timers.forEach((timer) => {
+    sendTimer({ timer, client, framework })
+  })
+  await closeClient(client)
+}
+
+// The socket creation is delayed until the first packet is sent. In our
+// case, this happens just before `client.close()` is called, which is too
+// late and make it not send anything. We need to manually create it using
+// the internal API.
+const startClient = async function (host, port) {
+  const client = new StatsdClient({ host, port, socketTimeout: 0 })
+  // eslint-disable-next-line no-underscore-dangle
+  await promisify(client._socket._createSocket.bind(client._socket))()
+  return client
+}
+
+const sendTimer = function ({ timer: { metricName, stageTag, parentTag, durationNs, tags }, client, framework }) {
+  const durationMs = roundTimerToMillisecs(durationNs)
+  const frameworkTag = framework === undefined ? {} : { framework }
+  client.distribution(metricName, durationMs, { stage: stageTag, parent: parentTag, ...tags, ...frameworkTag })
+}
+
+// UDP packets are buffered and flushed at regular intervals by statsd-client.
+// Closing force flushing all of them.
+const closeClient = async function (client) {
+  client.close()
+
+  // statsd-clent does not provide with a way of knowing when the socket is done
+  // closing, so we need to use the following hack.
+  await pSetTimeout(CLOSE_TIMEOUT)
+  await pSetTimeout(CLOSE_TIMEOUT)
+}
+
+// See https://github.com/msiebuhr/node-statsd-client/blob/45a93ee4c94ca72f244a40b06cb542d4bd7c3766/lib/EphemeralSocket.js#L81
+const CLOSE_TIMEOUT = 11

package/src/utils/errors.js

@@ -0,0 +1,12 @@
+// Wrap an async function so it prepends an error message on exceptions.
+// This helps locate errors.
+export const addAsyncErrorMessage = function (asyncFunc, message) {
+  return async (...args) => {
+    try {
+      return await asyncFunc(...args)
+    } catch (error) {
+      error.stack = `${message}: ${error.stack}`
+      throw error
+    }
+  }
+}

package/src/utils/json.js

@@ -0,0 +1,19 @@
+import { promises as fs, readFileSync } from 'fs'
+import { fileURLToPath } from 'url'
+
+const ROOT_PACKAGE_JSON_PATH = fileURLToPath(new URL('../../package.json', import.meta.url))
+
+// TODO: Replace with dynamic `import()` once it is supported without
+// experimental flags
+export const importJsonFile = async function (filePath) {
+  const fileContents = await fs.readFile(filePath)
+  return JSON.parse(fileContents)
+}
+
+const importJsonFileSync = function (filePath) {
+  // Use sync I/O so it is easier to migrate to `import()` later on
+  const fileContents = readFileSync(filePath, 'utf8')
+  return JSON.parse(fileContents)
+}
+
+export const ROOT_PACKAGE_JSON = importJsonFileSync(ROOT_PACKAGE_JSON_PATH)

package/src/utils/omit.js

@@ -0,0 +1,6 @@
+import filterObj from 'filter-obj'
+
+// lodash.omit is 1400 lines of codes. filter-obj is much smaller and simpler.
+export const omit = function (obj, keys) {
+  return filterObj(obj, (key) => !keys.includes(key))
+}

package/src/utils/package.js

@@ -0,0 +1,23 @@
+import { dirname } from 'path'
+
+import { readPackageUp } from 'read-pkg-up'
+
+// Retrieve `package.json` from a specific directory
+export const getPackageJson = async function (cwd, { normalize } = {}) {
+  const packageObj = await getPackageObj({ cwd, normalize })
+  if (packageObj === undefined) {
+    return { packageJson: {} }
+  }
+
+  const { path, packageJson } = packageObj
+  const packageDir = dirname(path)
+  return { packageDir, packageJson }
+}
+
+const getPackageObj = async function ({ cwd, normalize = true }) {
+  try {
+    return await readPackageUp({ cwd, normalize })
+    // If the `package.json` is invalid and `normalize` is `true`, an error is
+    // thrown. We return `undefined` then.
+  } catch {}
+}

package/src/utils/remove_falsy.js

@@ -0,0 +1,10 @@
+import filterObj from 'filter-obj'
+
+// Remove falsy values from object
+export const removeFalsy = function (obj) {
+  return filterObj(obj, isDefined)
+}
+
+const isDefined = function (key, value) {
+  return value !== undefined && value !== ''
+}

package/src/utils/resolve.js

@@ -0,0 +1,46 @@
+import { createRequire } from 'module'
+
+import { async as resolveLib } from 'resolve'
+
+// TODO: use `import.resolve()` once it is available without any experimental
+// flags
+const require = createRequire(import.meta.url)
+
+// Like `resolvePath()` but does not throw
+export const tryResolvePath = async function (path, basedir) {
+  try {
+    const resolvedPath = await resolvePath(path, basedir)
+    return { path: resolvedPath }
+  } catch (error) {
+    return { error }
+  }
+}
+
+// This throws if the package cannot be found
+export const resolvePath = async function (path, basedir) {
+  try {
+    return await resolvePathWithBasedir(path, basedir)
+    // Fallback.
+    // `resolve` sometimes gives unhelpful error messages.
+    // https://github.com/browserify/resolve/issues/223
+  } catch {
+    return require.resolve(path, { paths: [basedir] })
+  }
+}
+
+// Like `require.resolve()` but as an external library.
+// We need to use `new Promise()` due to a bug with `utils.promisify()` on
+// `resolve`:
+//   https://github.com/browserify/resolve/issues/151#issuecomment-368210310
+const resolvePathWithBasedir = function (path, basedir) {
+  return new Promise((resolve, reject) => {
+    // eslint-disable-next-line promise/prefer-await-to-callbacks
+    resolveLib(path, { basedir }, (error, resolvedPath) => {
+      if (error) {
+        return reject(error)
+      }
+
+      resolve(resolvedPath)
+    })
+  })
+}

package/src/utils/runtime.js

@@ -0,0 +1,5 @@
+export const isRuntime = function (pluginOption) {
+  const { packageName } = pluginOption
+  // Make this a bit more robust in the future
+  return ['@netlify/next-runtime', '@netlify/plugin-nextjs'].includes(packageName)
+}

package/src/utils/semver.js

@@ -0,0 +1,34 @@
+import semver from 'semver'
+
+// Compare two versions by their major versions.
+// Takes into account the special rules for `0.*.*` and `0.0.*` versions.
+export const isPreviousMajor = function (versionA, versionB) {
+  return semver.lt(getMajor(versionA), getMajor(versionB))
+}
+
+// Remove minor/patch numbers
+const getMajor = function (version) {
+  return semver.minVersion(getMajorVersion(version)).version
+}
+
+// According to semver, the second number is the major release number for
+// `0.*.*` versions and the third for `0.0.*`. This is how `^` behaves with the
+// `semver` module which is used by `npm`.
+export const getMajorVersion = function (version) {
+  if (!version || semver.clean(version) === null) {
+    return
+  }
+
+  const majorVersion = semver.major(version)
+  if (majorVersion !== 0) {
+    return `${majorVersion}`
+  }
+
+  const minorVersion = semver.minor(version)
+  if (minorVersion !== 0) {
+    return `${majorVersion}.${minorVersion}`
+  }
+
+  const patchVersion = semver.patch(version)
+  return `${majorVersion}.${minorVersion}.${patchVersion}`
+}