use stream transform

packages/artifact/src/internal/download/download-artifact.ts

@@ -1,4 +1,5 @@
 import fs from 'fs/promises'
+import * as stream from 'stream'
 import {createWriteStream} from 'fs'
 import * as path from 'path'
 import * as github from '@actions/github'
@@ -85,8 +86,8 @@ export async function streamExtractExternal(
     }
     const timer = setTimeout(timerFn, timeout)
 
-    const promises: Promise<void>[] = []
     const createdDirectories = new Set<string>()
+    createdDirectories.add(directory)
     response.message
       .on('data', () => {
         timer.refresh()
@@ -99,8 +100,14 @@ export async function streamExtractExternal(
         reject(error)
       })
       .pipe(unzip.Parse())
-      .on('entry', (entry: unzip.Entry) => {
+      .pipe(
+        new stream.Transform({
+          objectMode: true,
+          transform: async (entry, _, callback) => {
             const fullPath = path.normalize(path.join(directory, entry.path))
+            if (!directory.endsWith(path.sep)) {
+              directory += path.sep
+            }
             if (!fullPath.startsWith(directory)) {
               reject(new Error(`Malformed extraction path: ${fullPath}`))
             }
@@ -108,38 +115,38 @@ export async function streamExtractExternal(
             core.debug(`Extracting artifact entry: ${fullPath}`)
             if (entry.type === 'Directory') {
               if (!createdDirectories.has(fullPath)) {
-            promises.push(resolveOrCreateDirectory(fullPath).then(() => {}))
                 createdDirectories.add(fullPath)
-          }
+                await resolveOrCreateDirectory(fullPath).then(() => {
                   entry.autodrain()
+                  callback()
+                })
+              } else {
+                entry.autodrain()
+                callback()
+              }
             } else {
               if (!createdDirectories.has(path.dirname(fullPath))) {
-            promises.push(
-              resolveOrCreateDirectory(path.dirname(fullPath)).then(() => {})
-            )
                 createdDirectories.add(path.dirname(fullPath))
+                await resolveOrCreateDirectory(path.dirname(fullPath)).then(
+                  () => {
+                    entry.autodrain()
+                    callback()
                   }
-          const writeStream = createWriteStream(fullPath)
-          promises.push(
-            new Promise((resolve, reject) => {
-              writeStream.on('finish', () => {
-                resolve()
-              })
-              writeStream.on('error', reject)
-            })
                 )
+              }
+
+              const writeStream = createWriteStream(fullPath)
+              writeStream.on('finish', callback)
+              writeStream.on('error', reject)
               entry.pipe(writeStream)
             }
-      })
-      .on('end', async () => {
-        clearTimeout(timer)
-        try {
-          await Promise.all(promises)
-          resolve()
-        } catch (error) {
-          reject(error)
           }
         })
+      )
+      .on('finish', async () => {
+        clearTimeout(timer)
+        resolve()
+      })
       .on('error', (error: Error) => {
         reject(error)
       })