chore: simplify CLI code

Author: barelyhuman

create-adex/cli.mjs

@@ -9,7 +9,7 @@ import { parseArgs } from 'node:util'
 import { finished } from 'stream/promises'
 import k from 'kleur'
 
-const TMP_FOLDER_PREFX = '.create-adex'
+const TMP_FOLDER_PREFIX = '.create-adex'
 const info = k.cyan
 const success = k.green
 const failure = k.red
@@ -36,108 +36,119 @@ const flags = parseArgs({
 await main()
 
 async function main() {
-  const { init, help } = flags.values
+  const { help } = flags.values
   const targetDir = flags.positionals[0] ?? '.'
 
   if (help) {
-    console.log(`
-${k.gray('[USAGE]')}
-
-    $ adex [flags] [args]
-
-${k.gray('[FLAGS]')}
-
-    --help,-h                     Show this help
-    --init PATH   Initialise a new adex project at PATH (${k.gray('default: ./')})
-
-    `)
+    showHelp()
     return
   }
 
-  if (existsSync(targetDir)) {
-    const entries = await readdir(targetDir)
-    if (entries.filter(d => d != '.tmp').length) {
-      console.log(
-        `${failure(`[FAIL]`)} ${k.bold(targetDir)} is not empty, aborting initialisation`
-      )
-      return
-    }
+  if (await isDirectoryNotEmpty(targetDir)) {
+    console.log(
+      `${failure(`[FAIL]`)} ${k.bold(targetDir)} is not empty, aborting initialization`
+    )
+    return
   }
+
   console.log(info(`Initializing in ${targetDir}`))
   const selectedTemplate = TEMPLATES.default
   const targetFilePath = await downloadFile(
     selectedTemplate.link,
     'adex-template.zip'
   )
 
-  const unzipStream = new StreamZip.async({
-    file: targetFilePath,
-  })
-
+  const unzipStream = new StreamZip.async({ file: targetFilePath })
   const entries = await unzipStream.entries()
 
-  const files = (
-    await Promise.all(
-      Object.values(entries).map(async entry => {
-        const outFile = join(TMP_FOLDER_PREFX, 'out', entry.name)
-        await mkdir(dirname(outFile), { recursive: true })
-        await unzipStream.extract(entry, outFile)
-        if (entry.isFile) {
-          return outFile
-        }
-      })
-    )
-  ).filter(Boolean)
-
-  await Promise.allSettled(
-    files
-      .map(d => {
-        const absolutePath = resolve(d)
-        return {
-          source: absolutePath,
-          dest: absolutePath.replace(
-            join(
-              process.cwd(),
-              TMP_FOLDER_PREFX,
-              'out',
-              selectedTemplate.name + '-' + selectedTemplate.branch
-            ),
-            resolve(targetDir)
-          ),
-        }
-      })
-      .map(async d => {
-        try {
-          await mkdir(dirname(d.dest), { recursive: true })
-          await copyFile(d.source, d.dest)
-          console.log(`${k.gray('[Created]')} ${k.white(d.dest)}`)
-        } catch (err) {
-          console.log(failure(`[FAIL] Creation: ${d.dest}, ${err.message}`))
-        }
-      })
-  )
+  const files = await extractFiles(entries, unzipStream)
+  await copyFiles(files, targetDir, selectedTemplate)
 
-  rm(TMP_FOLDER_PREFX, { recursive: true })
+  await rm(TMP_FOLDER_PREFIX, { recursive: true })
 
-  console.log(
-    `\nNext Steps\n
-$ cd ${targetDir}
-$ npm i`
-  )
+  console.log(`\nNext Steps\n$ cd ${targetDir}\n$ npm i`)
   console.log(success('\nDone!\n'))
+}
 
-  return
+function showHelp() {
+  console.log(`
+${k.gray('[USAGE]')}
+
+    $ adex [flags] [args]
+
+${k.gray('[FLAGS]')}
+
+    --help,-h                     Show this help
+    --init PATH                   Initialize a new adex project at PATH (${k.gray('default: ./')})
+  `)
+}
+
+async function isDirectoryNotEmpty(targetDir) {
+  if (existsSync(targetDir)) {
+    const entries = await readdir(targetDir)
+    return entries.filter(d => d !== '.tmp').length > 0
+  }
+  return false
 }
 
 async function downloadFile(url, fileName) {
-  const res = await fetch(url)
-  if (!existsSync(TMP_FOLDER_PREFX)) await mkdir(TMP_FOLDER_PREFX)
-  const destination = resolve(TMP_FOLDER_PREFX, fileName)
-  if (existsSync(destination)) {
-    await rm(destination, { recursive: true })
+  try {
+    const res = await fetch(url)
+    if (!res.ok) throw new Error(`Failed to fetch ${url}: ${res.statusText}`)
+
+    if (!existsSync(TMP_FOLDER_PREFIX)) await mkdir(TMP_FOLDER_PREFIX)
+    const destination = resolve(TMP_FOLDER_PREFIX, fileName)
+    if (existsSync(destination)) {
+      await rm(destination, { recursive: true })
+    }
+
+    const fileStream = createWriteStream(destination, { flags: 'wx' })
+    await finished(Readable.fromWeb(res.body).pipe(fileStream))
+    return destination
+  } catch (err) {
+    console.error(failure(`[FAIL] Download: ${err.message}`))
+    process.exit(1)
+  }
+}
+
+async function extractFiles(entries, unzipStream) {
+  const files = await Promise.all(
+    Object.values(entries).map(async entry => {
+      const outFile = join(TMP_FOLDER_PREFIX, 'out', entry.name)
+      await mkdir(dirname(outFile), { recursive: true })
+      await unzipStream.extract(entry, outFile)
+      if (entry.isFile) {
+        return outFile
+      }
+    })
+  )
+  return files.filter(Boolean)
+}
+
+async function copyFiles(files, targetDir, selectedTemplate) {
+  const copyPromises = files.map(d => {
+    const absolutePath = resolve(d)
+    const dest = absolutePath.replace(
+      join(
+        process.cwd(),
+        TMP_FOLDER_PREFIX,
+        'out',
+        `${selectedTemplate.name}-${selectedTemplate.branch}`
+      ),
+      resolve(targetDir)
+    )
+    return copyFileWithLogging(absolutePath, dest)
+  })
+
+  await Promise.allSettled(copyPromises)
+}
+
+async function copyFileWithLogging(source, dest) {
+  try {
+    await mkdir(dirname(dest), { recursive: true })
+    await copyFile(source, dest)
+    console.log(`${k.gray('[Created]')} ${k.white(dest)}`)
+  } catch (err) {
+    console.log(failure(`[FAIL] Creation: ${dest}, ${err.message}`))
   }
-  const fileStream = createWriteStream(destination, { flags: 'wx' })
-  // @ts-expect-error , supports the input but readable needs to be fixed for the same
-  await finished(Readable.fromWeb(res.body).pipe(fileStream))
-  return destination
 }