feat!: stop throwing error when directories do not exist (#6556)

* feat: stop throwing error when directories do not exist

* chore: re-add eslint rule

* chore: update test

* chore: fix assertion

Author: eduardoboucas

packages/zip-it-and-ship-it/src/utils/fs.ts

@@ -54,12 +54,11 @@ export const safeUnlink = async (path: string) => {
 
 // Takes a list of absolute paths and returns an array containing all the
 // filenames within those directories, if at least one of the directories
-// exists. If not, an error is thrown.
+// exists.
 export const listFunctionsDirectories = async function (srcFolders: string[]) {
   const filenamesByDirectory = await Promise.allSettled(
     srcFolders.map((srcFolder) => listFunctionsDirectory(srcFolder)),
   )
-  const errorMessages: string[] = []
   const validDirectories = filenamesByDirectory
     .map((result) => {
       if (result.status === 'rejected') {
@@ -77,11 +76,6 @@ export const listFunctionsDirectories = async function (srcFolders: string[]) {
     })
     .filter(nonNullable)
 
-  if (validDirectories.length === 0) {
-    throw new Error(`Functions folders do not exist: ${srcFolders.join(', ')}
-${errorMessages.join('\n')}`)
-  }
-
   return validDirectories.flat()
 }
 

packages/zip-it-and-ship-it/tests/bin.test.ts

@@ -35,10 +35,10 @@ describe('CLI', () => {
 
   test('Error execution', async () => {
     const tmpDir = await tmpName({ prefix: 'zip-it-bin-test' })
-    const { exitCode, stderr } = await exec(['doesNotExist', join(tmpDir, 'destFolder')], { reject: false })
+    const { stdout } = await exec(['doesNotExist', join(tmpDir, 'destFolder')], { reject: false })
+    const zipped = JSON.parse(stdout)
 
-    expect(exitCode).toBe(1)
-    expect(stderr).not.toBe('')
+    expect(zipped).toHaveLength(0)
   })
 
   test('Should throw on missing srcFolder', async () => {

packages/zip-it-and-ship-it/tests/list_functions_files.test.ts

@@ -40,21 +40,13 @@ describe('listFunctionsFiles', () => {
     },
   )
 
-  test('listFunctionsFiles throws if all function directories do not exist', async () => {
-    await expect(
-      async () =>
-        await listFunctionsFiles([
-          join(FIXTURES_DIR, 'missing-functions-folder', 'functions'),
-          join(FIXTURES_DIR, 'missing-functions-folder', 'functions2'),
-        ]),
-    ).rejects.toThrow(/Functions folders do not exist: /)
-  })
+  test('listFunctionsFiles returns an empty array if none of the function directories exist', async () => {
+    const files = await listFunctionsFiles([
+      join(FIXTURES_DIR, 'missing-functions-folder', 'functions'),
+      join(FIXTURES_DIR, 'missing-functions-folder', 'functions2'),
+    ])
 
-  test('listFunctionsFiles does not hide errors that have nothing todo with folder existents', async () => {
-    // @ts-expect-error test
-    await expect(() => listFunctionsFiles([true])).rejects.toThrow(
-      expect.not.stringContaining('Functions folders do not exist:'),
-    )
+    expect(files).toStrictEqual([])
   })
 
   test('listFunctionsFiles includes in-source config declarations', async () => {

packages/zip-it-and-ship-it/tests/main.test.ts

@@ -708,10 +708,6 @@ describe('zip-it-and-ship-it', () => {
     })
   })
 
-  testMany('Throws when the source folder does not exist', [...allBundleConfigs, 'bundler_none'], async (options) => {
-    await expect(zipNode('does-not-exist', { opts: options })).rejects.toThrowError(/Functions folders do not exist/)
-  })
-
   testMany(
     'Works even if destination folder does not exist',
     [...allBundleConfigs, 'bundler_none'],
@@ -3059,3 +3055,59 @@ test('Supports functions inside the plugins modules path', async () => {
 
   await tmpDir.cleanup()
 })
+
+test('Supports individual functions even when none of the given function directories exist', async () => {
+  const tmpDir = await getTmpDir({
+    // Cleanup the folder even if there are still files in them
+    unsafeCleanup: true,
+  })
+  const basePath = join(FIXTURES_ESM_DIR, 'v2-api-files-and-directories')
+  const files = await zipFunctions(
+    {
+      generated: {
+        directories: [join(basePath, 'does-not-exist/functions')],
+        functions: [
+          join(basePath, 'cat.jpg'),
+          join(basePath, 'func2.mjs'),
+          join(basePath, 'func3'),
+          join(basePath, 'func4'),
+        ],
+      },
+      user: {
+        directories: [join(basePath, 'does-not-exist-either/functions')],
+      },
+    },
+    tmpDir.path,
+    {
+      basePath,
+    },
+  )
+
+  expect(files.length).toBe(3)
+
+  const unzippedFunctions = await unzipFiles(files)
+  const functions = getFunctionResultsByName(unzippedFunctions)
+
+  const func2 = await importFunctionFile(`${tmpDir.path}/${functions.func2.name}/${functions.func2.entryFilename}`)
+  const func2Result = await invokeLambda(func2)
+  expect(func2Result.statusCode).toBe(200)
+  expect(await readAsBuffer(func2Result.body)).toStrictEqual(
+    JSON.stringify({ func: 2, mod3: 'module-3', mod4: 'module-4' }),
+  )
+
+  const func3 = await importFunctionFile(`${tmpDir.path}/${functions.func3.name}/${functions.func3.entryFilename}`)
+  const func3Result = await invokeLambda(func3)
+  expect(func3Result.statusCode).toBe(200)
+  expect(await readAsBuffer(func3Result.body)).toStrictEqual(
+    JSON.stringify({ func: 3, mod3: 'module-3', mod4: 'module-4' }),
+  )
+
+  const func4 = await importFunctionFile(`${tmpDir.path}/${functions.func4.name}/${functions.func4.entryFilename}`)
+  const func4Result = await invokeLambda(func4)
+  expect(func4Result.statusCode).toBe(200)
+  expect(await readAsBuffer(func4Result.body)).toStrictEqual(
+    JSON.stringify({ func: 4, mod3: 'module-3', mod4: 'module-4' }),
+  )
+
+  await tmpDir.cleanup()
+})