netlify-cli 15.5.1 → 15.7.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "15.5.1",
+  "version": "15.7.0",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
@@ -44,14 +44,15 @@
   "dependencies": {
     "@bugsnag/js": "7.20.2",
     "@fastify/static": "6.10.2",
-    "@netlify/build": "29.12.4",
-    "@netlify/build-info": "7.0.6",
-    "@netlify/config": "20.4.6",
+    "@netlify/build": "29.12.8",
+    "@netlify/build-info": "7.0.8",
+    "@netlify/config": "20.5.1",
     "@netlify/edge-bundler": "8.16.2",
     "@netlify/framework-info": "9.8.10",
     "@netlify/local-functions-proxy": "1.1.1",
-    "@netlify/zip-it-and-ship-it": "9.9.1",
-    "@octokit/rest": "19.0.11",
+    "@netlify/serverless-functions-api": "1.5.1",
+    "@netlify/zip-it-and-ship-it": "9.10.0",
+    "@octokit/rest": "19.0.13",
     "@skn0tt/lambda-local": "2.0.3",
     "ansi-escapes": "6.2.0",
     "ansi-styles": "6.2.1",
@@ -73,7 +74,7 @@
     "copy-template-dir": "1.4.0",
     "cron-parser": "4.8.1",
     "debug": "4.3.4",
-    "decache": "4.6.1",
+    "decache": "4.6.2",
     "dot-prop": "7.2.0",
     "dotenv": "16.0.3",
     "env-paths": "3.0.0",
@@ -132,7 +133,7 @@
     "pump": "3.0.0",
     "raw-body": "2.5.2",
     "read-pkg-up": "9.1.0",
-    "semver": "7.5.1",
+    "semver": "7.5.3",
     "source-map-support": "0.5.21",
     "strip-ansi-control-characters": "2.0.0",
     "tabtab": "3.0.2",

package/src/commands/base-command.mjs

@@ -527,6 +527,7 @@ export default class BaseCommand extends Command {
         pathPrefix,
         scheme,
         offline,
+        siteFeatureFlagPrefix: 'cli',
       })
     } catch (error_) {
       const isUserError = error_.customErrorInfo !== undefined && error_.customErrorInfo.type === 'resolveConfig'

package/src/commands/dev/dev.mjs

@@ -172,6 +172,10 @@ const dev = async (options, command) => {
     siteUrl,
     capabilities,
     timeouts,
+    geolocationMode: options.geo,
+    geoCountry: options.country,
+    offline: options.offline,
+    state,
   })
 
   // Try to add `.netlify` to `.gitignore`.
@@ -198,8 +202,6 @@ const dev = async (options, command) => {
     configPath: configPathOverride,
     debug: options.debug,
     env,
-    geolocationMode: options.geo,
-    geoCountry: options.country,
     getUpdatedConfig,
     inspectSettings,
     offline: options.offline,
@@ -207,6 +209,8 @@ const dev = async (options, command) => {
     site,
     siteInfo,
     state,
+    geolocationMode: options.geo,
+    geoCountry: options.country,
   })
 
   if (devConfig.autoLaunch !== false) {

package/src/commands/functions/functions-create.mjs

@@ -100,7 +100,6 @@ const formatRegistryArrayForInquirer = async function (lang, funcType) {
       .filter((folderName) => !folderName.endsWith('.md'))
       .map(async (folderName) => {
         const templatePath = path.join(templatesDir, lang, folderName, '.netlify-function-template.mjs')
-        // eslint-disable-next-line import/no-dynamic-require
         const template = await import(pathToFileURL(templatePath))
 
         return template.default
@@ -362,7 +361,6 @@ const downloadFromURL = async function (command, options, argumentName, function
   if (await fileExistsAsync(fnTemplateFile)) {
     const {
       default: { addons = [], onComplete },
-      // eslint-disable-next-line import/no-dynamic-require
     } = await import(pathToFileURL(fnTemplateFile).href)
 
     await installAddons(command, addons, path.resolve(fnFolder))
@@ -387,7 +385,6 @@ const getNpmInstallPackages = (existingPackages = {}, neededPackages = {}) =>
 // we don't do this check, we may be upgrading the version of a module used in
 // another part of the project, which we don't want to do.
 const installDeps = async ({ functionPackageJson, functionPath, functionsDir }) => {
-  // eslint-disable-next-line import/no-dynamic-require
   const { dependencies: functionDependencies, devDependencies: functionDevDependencies } = require(functionPackageJson)
   const sitePackageJson = await findUp('package.json', { cwd: functionsDir })
   const npmInstallFlags = ['--no-audit', '--no-fund']
@@ -401,7 +398,6 @@ const installDeps = async ({ functionPackageJson, functionPath, functionsDir })
     return
   }
 
-  // eslint-disable-next-line import/no-dynamic-require
   const { dependencies: siteDependencies, devDependencies: siteDevDependencies } = require(sitePackageJson)
   const dependencies = getNpmInstallPackages(siteDependencies, functionDependencies)
   const devDependencies = getNpmInstallPackages(siteDevDependencies, functionDevDependencies)

package/src/commands/functions/functions-invoke.mjs

@@ -68,7 +68,7 @@ const processPayloadFromFlag = function (payloadString) {
     if (pathexists) {
       try {
         // there is code execution potential here
-        // eslint-disable-next-line import/no-dynamic-require
+
         payload = require(payloadpath)
         return payload
       } catch (error_) {

package/src/commands/functions/functions-serve.mjs

@@ -13,7 +13,7 @@ const DEFAULT_PORT = 9999
  * @param {import('../base-command.mjs').default} command
  */
 const functionsServe = async (options, command) => {
-  const { api, config, site, siteInfo } = command.netlify
+  const { api, config, site, siteInfo, state } = command.netlify
 
   const functionsDir = getFunctionsDir({ options, config }, join('netlify', 'functions'))
   let { env } = command.netlify.cachedConfig
@@ -48,6 +48,10 @@ const functionsServe = async (options, command) => {
     timeouts,
     functionsPrefix: '/.netlify/functions/',
     buildersPrefix: '/.netlify/builders/',
+    geolocationMode: options.geo,
+    geoCountry: options.country,
+    offline: options.offline,
+    state,
   })
 }
 

package/src/commands/recipes/common.mjs

@@ -8,7 +8,7 @@ export const getRecipe = async (name) => {
   const recipePath = resolve(directoryPath, '../../recipes', name, 'index.mjs')
 
   // windows needs a URL for absolute paths
-  // eslint-disable-next-line import/no-dynamic-require
+
   const recipe = await import(pathToFileURL(recipePath).href)
 
   return recipe
@@ -22,7 +22,7 @@ export const listRecipes = async () => {
       const recipePath = join(recipesPath, name, 'index.mjs')
 
       // windows needs a URL for absolute paths
-      // eslint-disable-next-line import/no-dynamic-require
+
       const recipe = await import(pathToFileURL(recipePath).href)
 
       return {

package/src/commands/serve/serve.mjs

@@ -101,6 +101,10 @@ const serve = async (options, command) => {
     siteUrl,
     capabilities,
     timeouts,
+    geolocationMode: options.geo,
+    geoCountry: options.country,
+    offline: options.offline,
+    state,
   })
 
   // Try to add `.netlify` to `.gitignore`.

package/src/lib/functions/runtimes/js/builders/zisi.mjs

@@ -22,11 +22,25 @@ const addFunctionsConfigDefaults = (config) => ({
   },
 })
 
-const buildFunction = async ({ cache, config, directory, func, hasTypeModule, projectRoot, targetDirectory }) => {
+/**
+ * @param {object} params
+ * @param {import("@netlify/zip-it-and-ship-it/dist/feature_flags.js").FeatureFlags} params.featureFlags
+ */
+const buildFunction = async ({
+  cache,
+  config,
+  directory,
+  featureFlags,
+  func,
+  hasTypeModule,
+  projectRoot,
+  targetDirectory,
+}) => {
   const zipOptions = {
     archiveFormat: 'none',
     basePath: projectRoot,
     config,
+    featureFlags: { ...featureFlags, zisi_functions_api_v2: true },
   }
   const functionDirectory = path.dirname(func.mainFile)
 
@@ -42,9 +56,11 @@ const buildFunction = async ({ cache, config, directory, func, hasTypeModule, pr
   // this case, we use `mainFile` as the function path of `zipFunction`.
   const entryPath = functionDirectory === directory ? func.mainFile : functionDirectory
   const {
+    entryFilename,
     includedFiles,
     inputs,
     path: functionPath,
+    runtimeAPIVersion,
     schedule,
   } = await memoizedBuild({
     cache,
@@ -52,7 +68,7 @@ const buildFunction = async ({ cache, config, directory, func, hasTypeModule, pr
     command: () => zipFunction(entryPath, targetDirectory, zipOptions),
   })
   const srcFiles = inputs.filter((inputPath) => !inputPath.includes(`${path.sep}node_modules${path.sep}`))
-  const buildPath = path.join(functionPath, `${func.name}.js`)
+  const buildPath = path.join(functionPath, entryFilename)
 
   // some projects include a package.json with "type=module", forcing Node to interpret every descending file
   // as ESM. ZISI outputs CJS, so we emit an overriding directive into the output directory.
@@ -67,7 +83,7 @@ const buildFunction = async ({ cache, config, directory, func, hasTypeModule, pr
 
   clearFunctionsCache(targetDirectory)
 
-  return { buildPath, includedFiles, srcFiles, schedule }
+  return { buildPath, includedFiles, runtimeAPIVersion, srcFiles, schedule }
 }
 
 /**
@@ -76,14 +92,14 @@ const buildFunction = async ({ cache, config, directory, func, hasTypeModule, pr
  * @param {string} params.mainFile
  * @param {string} params.projectRoot
  */
-export const parseForSchedule = async ({ config, mainFile, projectRoot }) => {
+export const parseFunctionForMetadata = async ({ config, mainFile, projectRoot }) => {
   const { listFunction } = await import('@netlify/zip-it-and-ship-it')
-  const listedFunction = await listFunction(mainFile, {
+
+  return await listFunction(mainFile, {
     config: netlifyConfigToZisiConfig({ config, projectRoot }),
+    featureFlags: { zisi_functions_api_v2: true },
     parseISC: true,
   })
-
-  return listedFunction && listedFunction.schedule
 }
 
 // Clears the cache for any files inside the directory from which functions are
@@ -109,26 +125,44 @@ const getTargetDirectory = async ({ errorExit }) => {
 const netlifyConfigToZisiConfig = ({ config, projectRoot }) =>
   addFunctionsConfigDefaults(normalizeFunctionsConfig({ functionsConfig: config.functions, projectRoot }))
 
-export default async function handler({ config, directory, errorExit, func, projectRoot }) {
+export default async function handler({ config, directory, errorExit, func, metadata, projectRoot }) {
   const functionsConfig = netlifyConfigToZisiConfig({ config, projectRoot })
 
   const packageJson = await readPackageUp(func.mainFile)
   const hasTypeModule = packageJson && packageJson.packageJson.type === 'module'
 
-  // We must use esbuild for certain file extensions.
-  const mustTranspile = ['.mjs', '.ts'].includes(path.extname(func.mainFile))
-  const mustUseEsbuild = hasTypeModule || mustTranspile
-
-  if (mustUseEsbuild && !functionsConfig['*'].nodeBundler) {
-    functionsConfig['*'].nodeBundler = 'esbuild'
-  }
-
-  // TODO: Resolve functions config globs so that we can check for the bundler
-  // on a per-function basis.
-  const isUsingEsbuild = ['esbuild_zisi', 'esbuild'].includes(functionsConfig['*'].nodeBundler)
-
-  if (!isUsingEsbuild) {
-    return false
+  /** @type {import("@netlify/zip-it-and-ship-it/dist/feature_flags.js").FeatureFlags} */
+  const featureFlags = {}
+
+  if (metadata.runtimeAPIVersion === 2) {
+    // For TypeScript we use NFT, otherwise we leave the file untouched with the `none` bundler
+    const isTypescript = ['.ts', '.mts', '.cts'].includes(path.extname(func.mainFile))
+
+    if (isTypescript) {
+      functionsConfig['*'].nodeBundler = 'nft'
+    } else {
+      // using esbuild is less performant than `none`, but it emits sourcemaps and thus
+      // enables debugging functions
+      functionsConfig['*'].nodeBundler = 'esbuild'
+      featureFlags.zisi_pure_esm = true
+      featureFlags.zisi_pure_esm_mjs = true
+    }
+  } else {
+    // We must use esbuild for certain file extensions.
+    const mustTranspile = ['.mjs', '.ts', '.mts', '.cts'].includes(path.extname(func.mainFile))
+    const mustUseEsbuild = hasTypeModule || mustTranspile
+
+    if (mustUseEsbuild && !functionsConfig['*'].nodeBundler) {
+      functionsConfig['*'].nodeBundler = 'esbuild'
+    }
+
+    // TODO: Resolve functions config globs so that we can check for the bundler
+    // on a per-function basis.
+    const isUsingEsbuild = ['esbuild_zisi', 'esbuild'].includes(functionsConfig['*'].nodeBundler)
+
+    if (!isUsingEsbuild) {
+      return false
+    }
   }
 
   // Enable source map support.
@@ -138,7 +172,16 @@ export default async function handler({ config, directory, errorExit, func, proj
 
   return {
     build: ({ cache = {} }) =>
-      buildFunction({ cache, config: functionsConfig, directory, func, projectRoot, targetDirectory, hasTypeModule }),
+      buildFunction({
+        cache,
+        config: functionsConfig,
+        directory,
+        func,
+        projectRoot,
+        targetDirectory,
+        hasTypeModule,
+        featureFlags,
+      }),
     builderName: 'zip-it-and-ship-it',
     target: targetDirectory,
   }

package/src/lib/functions/runtimes/js/constants.mjs

@@ -0,0 +1 @@
+export const SECONDS_TO_MILLISECONDS = 1000

package/src/lib/functions/runtimes/js/index.mjs

@@ -1,15 +1,17 @@
+import { createConnection } from 'net'
 import { dirname } from 'path'
+import { pathToFileURL } from 'url'
+import { Worker } from 'worker_threads'
 
 import lambdaLocal from '@skn0tt/lambda-local'
 import winston from 'winston'
 
 import detectNetlifyLambdaBuilder from './builders/netlify-lambda.mjs'
-import detectZisiBuilder, { parseForSchedule } from './builders/zisi.mjs'
+import detectZisiBuilder, { parseFunctionForMetadata } from './builders/zisi.mjs'
+import { SECONDS_TO_MILLISECONDS } from './constants.mjs'
 
 export const name = 'js'
 
-const SECONDS_TO_MILLISECONDS = 1000
-
 let netlifyLambdaDetectorCache
 
 const logger = winston.createLogger({
@@ -37,7 +39,8 @@ export const getBuildFunction = async ({ config, directory, errorExit, func, pro
     return netlifyLambdaBuilder.build
   }
 
-  const zisiBuilder = await detectZisiBuilder({ config, directory, errorExit, func, projectRoot })
+  const metadata = await parseFunctionForMetadata({ mainFile: func.mainFile, config, projectRoot })
+  const zisiBuilder = await detectZisiBuilder({ config, directory, errorExit, func, metadata, projectRoot })
 
   if (zisiBuilder) {
     return zisiBuilder.build
@@ -48,15 +51,55 @@ export const getBuildFunction = async ({ config, directory, errorExit, func, pro
   // main file otherwise.
   const functionDirectory = dirname(func.mainFile)
   const srcFiles = functionDirectory === directory ? [func.mainFile] : [functionDirectory]
-  const schedule = await parseForSchedule({ mainFile: func.mainFile, config, projectRoot })
 
-  return () => ({ schedule, srcFiles })
+  return () => ({ schedule: metadata.schedule, srcFiles })
 }
 
+const workerURL = new URL('worker.mjs', import.meta.url)
+
 export const invokeFunction = async ({ context, event, func, timeout }) => {
+  if (func.buildData.runtimeAPIVersion !== 2) {
+    return await invokeFunctionDirectly({ context, event, func, timeout })
+  }
+
+  const workerData = {
+    clientContext: JSON.stringify(context),
+    event,
+    // If a function builder has defined a `buildPath` property, we use it.
+    // Otherwise, we'll invoke the function's main file.
+    // Because we use import() we have to use file:// URLs for Windows.
+    entryFilePath: pathToFileURL(func.buildData?.buildPath ?? func.mainFile).href,
+    timeoutMs: timeout * SECONDS_TO_MILLISECONDS,
+  }
+
+  const worker = new Worker(workerURL, { workerData })
+  return await new Promise((resolve, reject) => {
+    worker.on('message', (result) => {
+      if (result?.streamPort) {
+        const client = createConnection(
+          {
+            port: result.streamPort,
+            host: 'localhost',
+          },
+          () => {
+            result.body = client
+            resolve(result)
+          },
+        )
+        client.on('error', reject)
+      } else {
+        resolve(result)
+      }
+    })
+
+    worker.on('error', reject)
+  })
+}
+
+export const invokeFunctionDirectly = async ({ context, event, func, timeout }) => {
   // If a function builder has defined a `buildPath` property, we use it.
   // Otherwise, we'll invoke the function's main file.
-  const lambdaPath = (func.buildData && func.buildData.buildPath) || func.mainFile
+  const lambdaPath = func.buildData?.buildPath ?? func.mainFile
   const result = await lambdaLocal.execute({
     clientContext: JSON.stringify(context),
     event,

package/src/lib/functions/runtimes/js/worker.mjs

@@ -0,0 +1,49 @@
+import { createServer } from 'net'
+import { isMainThread, workerData, parentPort } from 'worker_threads'
+
+import lambdaLocal from '@skn0tt/lambda-local'
+import { isStream } from 'is-stream'
+import sourceMapSupport from 'source-map-support'
+
+if (isMainThread) {
+  throw new Error(`Do not import "${import.meta.url}" in the main thread.`)
+}
+
+sourceMapSupport.install()
+
+lambdaLocal.getLogger().level = 'warn'
+
+const { clientContext, entryFilePath, event, timeoutMs } = workerData
+
+const lambdaFunc = await import(entryFilePath)
+
+const result = await lambdaLocal.execute({
+  clientContext,
+  event,
+  lambdaFunc,
+  region: 'dev',
+  timeoutMs,
+  verboseLevel: 3,
+})
+
+// When the result body is a StreamResponse
+// we open up a http server that proxies back to the main thread.
+if (result && isStream(result.body)) {
+  const { body } = result
+  delete result.body
+  await new Promise((resolve, reject) => {
+    const server = createServer((socket) => {
+      body.pipe(socket).on('end', () => server.close())
+    })
+    server.on('error', (error) => {
+      reject(error)
+    })
+    server.listen({ port: 0, host: 'localhost' }, () => {
+      const { port } = server.address()
+      result.streamPort = port
+      resolve()
+    })
+  })
+}
+
+parentPort.postMessage(result)

package/src/lib/functions/server.mjs

@@ -3,6 +3,8 @@ import jwtDecode from 'jwt-decode'
 
 import { NETLIFYDEVERR, NETLIFYDEVLOG, error as errorExit, log } from '../../utils/command-helpers.mjs'
 import { CLOCKWORK_USERAGENT, getFunctionsDistPath, getInternalFunctionsDir } from '../../utils/functions/index.mjs'
+import { headers as efHeaders } from '../edge-functions/headers.mjs'
+import { getGeoLocation } from '../geo-location.mjs'
 
 import { handleBackgroundFunction, handleBackgroundFunctionResult } from './background.mjs'
 import { createFormSubmissionHandler } from './form-submissions-handler.mjs'
@@ -102,10 +104,15 @@ export const createHandler = function (options) {
       (prev, [key, value]) => ({ ...prev, [key]: Array.isArray(value) ? value : [value] }),
       {},
     )
-    const headers = Object.entries({ ...request.headers, 'client-ip': [remoteAddress] }).reduce(
-      (prev, [key, value]) => ({ ...prev, [key]: Array.isArray(value) ? value : [value] }),
-      {},
-    )
+
+    const geoLocation = await getGeoLocation({ ...options, mode: options.geo })
+
+    const headers = Object.entries({
+      ...request.headers,
+      'client-ip': [remoteAddress],
+      'x-nf-client-connection-ip': [remoteAddress],
+      [efHeaders.Geo]: JSON.stringify(geoLocation),
+    }).reduce((prev, [key, value]) => ({ ...prev, [key]: Array.isArray(value) ? value : [value] }), {})
     const rawQuery = new URLSearchParams(requestQuery).toString()
     const protocol = options.config?.dev?.https ? 'https' : 'http'
     const url = new URL(requestPath, `${protocol}://${request.get('host') || 'localhost'}`)

package/src/lib/functions/synchronous.mjs

@@ -73,7 +73,7 @@ const formatLambdaLocalError = (err, acceptsHtml) =>
         errorMessage: err.errorMessage,
         trace: err.stackTrace,
       })
-    : `${err.errorType}: ${err.errorMessage}\n ${err.stackTrace.join('\n ')}`
+    : `${err.errorType}: ${err.errorMessage}\n ${err.stackTrace?.join('\n ')}`
 
 const processRenderedResponse = async (err, request) => {
   const acceptsHtml = request.headers && request.headers.accept && request.headers.accept.includes('text/html')
@@ -102,7 +102,7 @@ const validateLambdaResponse = (lambdaResponse) => {
   }
   if (!Number(lambdaResponse.statusCode)) {
     return {
-      error: `Your function response must have a numerical statusCode. You gave: $ ${lambdaResponse.statusCode}`,
+      error: `Your function response must have a numerical statusCode. You gave: ${lambdaResponse.statusCode}`,
     }
   }
   if (lambdaResponse.body && typeof lambdaResponse.body !== 'string' && !isStream(lambdaResponse.body)) {

package/src/utils/execa.mjs

@@ -10,7 +10,6 @@ import { env } from 'process'
 let execa
 
 if (env.NETLIFY_CLI_EXECA_PATH) {
-  // eslint-disable-next-line import/no-dynamic-require
   const execaMock = await import(env.NETLIFY_CLI_EXECA_PATH)
   execa = execaMock.default
 } else {

package/src/utils/feature-flags.mjs

@@ -0,0 +1,19 @@
+/**
+ * Allows us to check if a feature flag is enabled for a site.
+ * Due to versioning of the cli, and the desire to remove flags from
+ * our feature flag service when they should always evaluate to true,
+ * we can't just look for the presense of {featureFlagName: true}, as
+ * the absense of a flag should also evaluate to the flag being enabled.
+ * Instead, we return that the feature flag is enabled if it isn't
+ * specifically set to false in the response
+ * @param {*} siteInfo
+ * @param {string} flagName
+ *
+ * @returns {boolean}
+ */
+export const isFeatureFlagEnabled = (flagName, siteInfo) => {
+  if (siteInfo.feature_flags && siteInfo.feature_flags[flagName] !== false) {
+    return true
+  }
+  return false
+}