netlify-cli 16.0.1 → 16.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "16.0.1",
+  "version": "16.0.3",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
@@ -44,13 +44,13 @@
   "dependencies": {
     "@bugsnag/js": "7.20.2",
     "@fastify/static": "6.10.2",
-    "@netlify/build": "29.20.0",
+    "@netlify/build": "29.20.4",
     "@netlify/build-info": "7.7.3",
     "@netlify/config": "20.8.0",
     "@netlify/edge-bundler": "8.17.1",
     "@netlify/local-functions-proxy": "1.1.1",
     "@netlify/serverless-functions-api": "1.5.2",
-    "@netlify/zip-it-and-ship-it": "9.13.1",
+    "@netlify/zip-it-and-ship-it": "9.15.1",
     "@octokit/rest": "19.0.13",
     "ansi-escapes": "6.2.0",
     "ansi-styles": "6.2.1",

package/src/commands/build/build.mjs

@@ -48,6 +48,7 @@ const build = async (options, command) => {
 
   const buildOptions = await getBuildOptions({
     cachedConfig,
+    packagePath: command.workspacePackage,
     token,
     options,
   })

package/src/commands/deploy/deploy.mjs

@@ -13,6 +13,7 @@ import prettyjson from 'prettyjson'
 
 import { cancelDeploy } from '../../lib/api.mjs'
 import { getBuildOptions, runBuild } from '../../lib/build.mjs'
+import { getBootstrapURL } from '../../lib/edge-functions/bootstrap.mjs'
 import { featureFlags as edgeFunctionsFeatureFlags } from '../../lib/edge-functions/consts.mjs'
 import { normalizeFunctionsConfig } from '../../lib/functions/config.mjs'
 import { BACKGROUND_FUNCTIONS_WARNING } from '../../lib/log.mjs'
@@ -323,6 +324,7 @@ const runDeploy = async ({
   deployToProduction,
   functionsConfig,
   functionsFolder,
+  packagePath,
   silent,
   site,
   siteData,
@@ -344,13 +346,13 @@ const runDeploy = async ({
     results = await api.createSiteDeploy({ siteId, title, body: { draft, branch: alias } })
     deployId = results.id
 
-    const internalFunctionsFolder = await getInternalFunctionsDir({ base: site.root })
+    const internalFunctionsFolder = await getInternalFunctionsDir({ base: site.root, packagePath })
 
     // The order of the directories matter: zip-it-and-ship-it will prioritize
     // functions from the rightmost directories. In this case, we want user
     // functions to take precedence over internal functions.
     const functionDirectories = [internalFunctionsFolder, functionsFolder].filter(Boolean)
-    const manifestPath = skipFunctionsCache ? null : await getFunctionsManifestPath({ base: site.root })
+    const manifestPath = skipFunctionsCache ? null : await getFunctionsManifestPath({ base: site.root, packagePath })
 
     // @ts-ignore
     results = await deploySite(api, siteId, deployFolder, {
@@ -366,6 +368,7 @@ const runDeploy = async ({
       workingDir: command.workingDir,
       manifestPath,
       skipFunctionsCache,
+      siteRoot: site.root,
     })
   } catch (error_) {
     if (deployId) {
@@ -399,16 +402,18 @@ const runDeploy = async ({
  *
  * @param {object} config
  * @param {*} config.cachedConfig
+ * @param {string} [config.packagePath]
  * @param {import('commander').OptionValues} config.options The options of the command
  * @returns
  */
-const handleBuild = async ({ cachedConfig, options }) => {
+const handleBuild = async ({ cachedConfig, options, packagePath }) => {
   if (!options.build) {
     return {}
   }
   const [token] = await getToken()
   const resolvedOptions = await getBuildOptions({
     cachedConfig,
+    packagePath,
     token,
     options,
   })
@@ -442,6 +447,7 @@ const bundleEdgeFunctions = async (options, command) => {
     packagePath: command.workspacePackage,
     buffer: true,
     featureFlags: edgeFunctionsFeatureFlags,
+    edgeFunctionsBootstrapURL: getBootstrapURL(),
   })
 
   if (!success) {
@@ -587,6 +593,7 @@ const deploy = async (options, command) => {
   }
 
   const { configMutations = [], newConfig } = await handleBuild({
+    packagePath: command.workspacePackage,
     cachedConfig: command.netlify.cachedConfig,
     options,
   })
@@ -652,6 +659,7 @@ const deploy = async (options, command) => {
     functionsConfig,
     // pass undefined functionsFolder if doesn't exist
     functionsFolder: functionsFolderStat && functionsFolder,
+    packagePath: command.workspacePackage,
     silent: options.json || options.silent,
     site,
     siteData,

package/src/lib/build.mjs

@@ -19,6 +19,7 @@ import { featureFlags as edgeFunctionsFeatureFlags } from './edge-functions/cons
  *
  * @param {object} config
  * @param {*} config.cachedConfig
+ * @param {string} [config.packagePath]
  * @param {string} config.token
  * @param {import('commander').OptionValues} config.options
  * @returns {BuildConfig}
@@ -26,10 +27,12 @@ import { featureFlags as edgeFunctionsFeatureFlags } from './edge-functions/cons
 export const getBuildOptions = ({
   cachedConfig,
   options: { context, cwd, debug, dry, json, offline, silent },
+  packagePath,
   token,
 }) => ({
   cachedConfig,
   siteId: cachedConfig.siteInfo.id,
+  packagePath,
   token,
   dry,
   debug,

package/src/lib/functions/server.mjs

@@ -219,6 +219,20 @@ const getFunctionsServer = (options) => {
   return app
 }
 
+/**
+ *
+ * @param {object} options
+ * @param {import('../../commands/base-command.mjs').default} options.command
+ * @param {*} options.capabilities
+ * @param {*} options.config
+ * @param {boolean} options.debug
+ * @param {*} options.loadDistFunctions
+ * @param {*} options.settings
+ * @param {*} options.site
+ * @param {string} options.siteUrl
+ * @param {*} options.timeouts
+ * @returns
+ */
 export const startFunctionsServer = async (options) => {
   const { capabilities, command, config, debug, loadDistFunctions, settings, site, siteUrl, timeouts } = options
   const internalFunctionsDir = await getInternalFunctionsDir({ base: site.root })
@@ -260,15 +274,22 @@ export const startFunctionsServer = async (options) => {
 
   const server = await getFunctionsServer(Object.assign(options, { functionsRegistry }))
 
-  await startWebServer({ server, settings })
+  await startWebServer({ server, settings, debug })
 }
 
-const startWebServer = async ({ server, settings }) => {
-  await new Promise((resolve) => {
-    server.listen(settings.functionsPort, (err) => {
+/**
+ *
+ * @param {object} config
+ * @param {boolean} config.debug
+ * @param {ReturnType<Awaited<typeof getFunctionsServer>>} config.server
+ * @param {*} config.settings
+ */
+const startWebServer = async ({ debug, server, settings }) => {
+  await new Promise((/** @type {(resolve: void) => void} */ resolve) => {
+    server.listen(settings.functionsPort, (/** @type {unknown} */ err) => {
       if (err) {
         errorExit(`${NETLIFYDEVERR} Unable to start functions server: ${err}`)
-      } else {
+      } else if (debug) {
         log(`${NETLIFYDEVLOG} Functions server is listening on ${settings.functionsPort}`)
       }
       resolve()

package/src/utils/deploy/deploy-site.mjs

@@ -40,6 +40,7 @@ export const deploySite = async (
     // API calls this the 'title'
     message: title,
     siteEnv,
+    siteRoot,
     skipFunctionsCache,
     statusCb = () => {
       /* default to noop */
@@ -78,6 +79,7 @@ export const deploySite = async (
         manifestPath,
         skipFunctionsCache,
         siteEnv,
+        rootDir: siteRoot,
       }),
     ])
   const edgeFunctionsCount = Object.keys(files).filter(isEdgeFunctionFile).length

package/src/utils/deploy/hash-fns.mjs

@@ -20,10 +20,10 @@ const getFunctionZips = async ({
   directories,
   functionsConfig,
   manifestPath,
+  rootDir,
   skipFunctionsCache,
   statusCb,
   tmpDir,
-  workingDir,
 }) => {
   statusCb({
     type: 'functions-manifest',
@@ -68,7 +68,7 @@ const getFunctionZips = async ({
   }
 
   return await zipFunctions(directories, tmpDir, {
-    basePath: workingDir,
+    basePath: rootDir,
     configFileDirectories: [getPathInProject([INTERNAL_FUNCTIONS_FOLDER])],
     config: functionsConfig,
   })

package/src/utils/functions/functions.mjs

@@ -19,15 +19,15 @@ export const SERVE_FUNCTIONS_FOLDER = 'functions-serve'
 export const getFunctionsDir = ({ config, options }, defaultValue) =>
   options.functions || config.dev?.functions || config.functionsDirectory || config.dev?.Functions || defaultValue
 
-export const getFunctionsManifestPath = async ({ base }) => {
-  const path = resolve(base, getPathInProject(['functions', 'manifest.json']))
+export const getFunctionsManifestPath = async ({ base, packagePath = '' }) => {
+  const path = resolve(base, packagePath, getPathInProject(['functions', 'manifest.json']))
   const isFile = await isFileAsync(path)
 
   return isFile ? path : null
 }
 
-export const getFunctionsDistPath = async ({ base }) => {
-  const path = resolve(base, getPathInProject(['functions']))
+export const getFunctionsDistPath = async ({ base, packagePath = '' }) => {
+  const path = resolve(base, packagePath, getPathInProject(['functions']))
   const isDirectory = await isDirectoryAsync(path)
 
   return isDirectory ? path : null
@@ -38,10 +38,11 @@ export const getFunctionsDistPath = async ({ base }) => {
  * @param {object} config
  * @param {string} config.base
  * @param {boolean=} config.ensureExists
+ * @param {string} config.packagePath
  * @returns
  */
-export const getInternalFunctionsDir = async ({ base, ensureExists }) => {
-  const path = resolve(base, getPathInProject([INTERNAL_FUNCTIONS_FOLDER]))
+export const getInternalFunctionsDir = async ({ base, ensureExists, packagePath = '' }) => {
+  const path = resolve(base, packagePath, getPathInProject([INTERNAL_FUNCTIONS_FOLDER]))
 
   if (ensureExists) {
     await fs.mkdir(path, { recursive: true })