Merge branch 'main' into chore/test-eslint

Author: LekoArts

packages/runtime/src/constants.ts

@@ -27,8 +27,10 @@ export const CATCH_ALL_REGEX = /\/\[\.{3}(.*)](.json)?$/
 export const OPTIONAL_CATCH_ALL_REGEX = /\/\[{2}\.{3}(.*)]{2}(.json)?$/
 export const DYNAMIC_PARAMETER_REGEX = /\/\[(.*?)]/g
 export const MINIMUM_REVALIDATE_SECONDS = 60
-// 50MB, which is the documented max, though the hard max seems to be higher
-export const LAMBDA_MAX_SIZE = 1024 * 1024 * 50
+// 50MB, which is the warning max
+export const LAMBDA_WARNING_SIZE = 1024 * 1024 * 50
+// 250MB, which is the hard max
+export const LAMBDA_MAX_SIZE = 1024 * 1024 * 250
 
 export const DIVIDER = `
 ────────────────────────────────────────────────────────────────

packages/runtime/src/helpers/verification.ts

@@ -2,13 +2,13 @@ import { existsSync, promises } from 'fs'
 import path, { relative, join } from 'path'
 
 import type { NetlifyConfig, NetlifyPluginUtils } from '@netlify/build'
-import { yellowBright, greenBright, blueBright, redBright, reset } from 'chalk'
+import { yellowBright, greenBright, blueBright, reset } from 'chalk'
 import { async as StreamZip } from 'node-stream-zip'
 import { outdent } from 'outdent'
 import prettyBytes from 'pretty-bytes'
 import { satisfies } from 'semver'
 
-import { LAMBDA_MAX_SIZE } from '../constants'
+import { LAMBDA_MAX_SIZE, LAMBDA_WARNING_SIZE } from '../constants'
 
 import { isBundleSizeCheckDisabled } from './utils'
 
@@ -105,7 +105,11 @@ export const checkForRootPublish = ({
   }
 }
 
-export const checkZipSize = async (file: string, maxSize: number = LAMBDA_MAX_SIZE): Promise<void> => {
+export const checkZipSize = async (
+  file: string,
+  maxSize: number = LAMBDA_MAX_SIZE,
+  warningSize: number = LAMBDA_WARNING_SIZE,
+): Promise<void> => {
   // Requires contacting the Netlify Support team to fully enable.
   // Enabling this without contacting them can result in failed deploys.
   if (isBundleSizeCheckDisabled()) {
@@ -120,15 +124,16 @@ export const checkZipSize = async (file: string, maxSize: number = LAMBDA_MAX_SI
     return
   }
   const fileSize = await promises.stat(file).then(({ size }) => size)
-  if (fileSize < maxSize) {
+  if (fileSize < warningSize) {
     return
   }
   // We don't fail the build, because the actual hard max size is larger so it might still succeed
   console.log(
-    redBright(outdent`
-      The function zip ${yellowBright(relative(process.cwd(), file))} size is ${prettyBytes(
+    yellowBright(outdent`
+      The function zip ${blueBright(relative(process.cwd(), file))} size is ${prettyBytes(
       fileSize,
-    )}, which is larger than the maximum supported size of ${prettyBytes(maxSize)}.
+    )}, which is larger than the recommended maximum size of ${prettyBytes(warningSize)}.
+      This will fail the build if the unzipped size is bigger than the maximum size of ${prettyBytes(maxSize)}.
       There are a few reasons this could happen. You may have accidentally bundled a large dependency, or you might have a
       large number of pre-rendered pages included.
     `),

test/helpers/verification.spec.ts

@@ -27,6 +27,12 @@ jest.mock('fs', () => ({
   existsSync: jest.fn(),
 }))
 
+// disable chalk colors to easier validate console text output
+jest.mock(`chalk`, () => {
+  process.env.FORCE_COLOR = '0'
+  return jest.requireActual('chalk')
+})
+
 describe('checkNextSiteHasBuilt', () => {
   let failBuildMock
 
@@ -96,23 +102,61 @@ describe('checkNextSiteHasBuilt', () => {
 })
 
 describe('checkZipSize', () => {
-  let consoleSpy
+  let consoleWarnSpy, consoleLogSpy
+  const { existsSync, promises } = require('fs')
 
   beforeEach(() => {
-    consoleSpy = jest.spyOn(global.console, 'warn')
+    consoleWarnSpy = jest.spyOn(global.console, 'warn')
+    consoleWarnSpy.mockClear()
+    consoleLogSpy = jest.spyOn(global.console, 'log')
+    consoleLogSpy.mockClear()
+    process.env.DISABLE_BUNDLE_ZIP_SIZE_CHECK = 'false'
   })
 
   afterEach(() => {
     delete process.env.DISABLE_BUNDLE_ZIP_SIZE_CHECK
   })
 
+  afterAll(() => {
+    consoleWarnSpy.mockReset()
+    consoleLogSpy.mockReset()
+    existsSync.mockReset()
+  })
+
   it('emits a warning that DISABLE_BUNDLE_ZIP_SIZE_CHECK was enabled', async () => {
     process.env.DISABLE_BUNDLE_ZIP_SIZE_CHECK = 'true'
     await checkZipSize(chance.string())
-    expect(consoleSpy).toHaveBeenCalledWith(
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
       'Function bundle size check was DISABLED with the DISABLE_BUNDLE_ZIP_SIZE_CHECK environment variable. Your deployment will break if it exceeds the maximum supported size of function zip files in your account.',
     )
   })
+
+  it('does not emit a warning if the file size is below the warning size', async () => {
+    existsSync.mockReturnValue(true)
+    jest.spyOn(promises, 'stat').mockResolvedValue({ size: 1024 * 1024 * 20 })
+
+    await checkZipSize('some-file.zip')
+
+    expect(consoleWarnSpy).not.toHaveBeenCalled()
+  })
+
+  it('emits a warning if the file size is above the warning size', async () => {
+    existsSync.mockReturnValue(true)
+    jest.spyOn(promises, 'stat').mockResolvedValue({ size: 1024 * 1024 * 200 })
+
+    try {
+      await checkZipSize('some-file.zip')
+    } catch {
+      // StreamZip is not mocked, so ultimately the call will throw an error,
+      // but we are logging message before that so we can assert it
+    }
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'The function zip some-file.zip size is 210 MB, which is larger than the recommended maximum size of 52.4 MB.',
+      ),
+    )
+  })
 })
 
 describeCwdTmpDir('getProblematicUserRewrites', () => {