feat: Remove friction from first use

* Add -C option to binary to prevent copying public gateway url to
  clipboard
* Add -P option to binary to pin only to local IPFS daemon, not remote
  services
* Update CLI help examples
* Add -h alias for --help
* Refactor nested callbacks with async/await

BREAKING CHANGE:

* Make 'public' default deploy path for binary
* Open public gateway URL on browser by default, use -O to opt-out
* Don't require signing up for anything with default options
 * Don't upload to pinata by default
 * Don't update cloudflare DNS by default, use -d cloudflare
 * Keep uploading to infura, which doesn't require signup
* Rework API options for deploy()

Author: agentofuser

bin/ipfs-deploy.js

@@ -8,97 +8,101 @@ require('dotenv').config()
 const argv = require('yargs')
   .scriptName('ipfs-deploy')
   .usage(
-    '$0 [options] path',
+    '$0 [options] [path]',
     'Pin path locally, upload to pinning service, and update DNS',
     yargs => {
       yargs
         .positional('path', {
           type: 'string',
-          default: './public/',
-          describe: 'The path to deploy',
+          describe: 'The local directory or file to be deployed',
+          default: 'public',
+          normalize: true,
         })
         .env('IPFS_DEPLOY')
         .options({
-          D: {
-            type: 'boolean',
-            default: false,
-            describe: "DON'T update Cloudflare DNS' TXT dnslink",
+          C: {
+            alias: 'no-clipboard',
+            describe: "DON'T copy ipfs.io/ipfs/<hash> to clipboard",
           },
-          o: {
+          d: {
+            alias: 'dns',
+            choices: ['cloudflare'],
+            describe: 'DNS provider whose dnslink TXT field will be updated',
+          },
+          O: {
             type: 'boolean',
-            default: false,
-            describe: 'Open URL after deploying',
+            describe: "DON'T open URL after deploying",
           },
           p: {
             alias: 'pinner',
             choices: ['pinata', 'infura'],
-            default: ['pinata', 'infura'],
+            default: ['infura'],
             describe: `Pinning services to which ${chalk.whiteBright(
               'path'
             )} will be uploaded`,
           },
           P: {
+            alias: 'no-remote-pin',
             type: 'boolean',
             default: false,
             describe:
               "DON'T pin remotely, only to local daemon (overrides -p)",
           },
         })
         .example(
-          '$0 _site',
+          '$0',
+          `# Deploys relative path "${chalk.whiteBright('public')}" to
+            ${chalk.whiteBright('ipfs.infura.io/ipfs/<hash>')}; doesn't ` +
+            'update DNS; copies and opens URL. These defaults are chosen ' +
+            'so as not to require signing up for any service or ' +
+            'setting up environment variables on first use.'
+        )
+        .example(
+          '$0 -p pinata _site',
           `# Deploys path "${chalk.whiteBright(
             '_site'
-          )}" to ${chalk.whiteBright('pinata')} and ${chalk.whiteBright(
-            'infura'
-          )}, and updates ${chalk.whiteBright('cloudflare')} DNS`
+          )}" ONLY to ${chalk.whiteBright('pinata')} and doesn't update DNS`
         )
         .example(
-          '$0 -p infura -p pinata',
+          '$0 -p infura -p pinata -d cloudflare',
           `# Deploys path "${chalk.whiteBright(
-            './public/'
+            'public'
           )}" to ${chalk.whiteBright('pinata')} and ${chalk.whiteBright(
             'infura'
-          )}, and updates ${chalk.whiteBright('cloudflare')} DNS`
-        )
-        .example(
-          '$0 -p pinata static',
-          `# Deploys path "${chalk.whiteBright(
-            'static'
-          )}" ONLY to ${chalk.whiteBright(
-            'pinata'
-          )} and updates ${chalk.whiteBright('cloudflare')} DNS`
+          )}, and updates cloudflare DNS`
         )
         .example(
-          '$0 -D docs',
-          `# Deploys path "${chalk.whiteBright(
-            'docs'
-          )}" to ${chalk.whiteBright('pinata')} and ${chalk.whiteBright(
-            'infura'
-          )}, and ${chalk.whiteBright("DON'T")} update DNS`
+          '$0 -COP docs',
+          `# Pins path "${chalk.whiteBright('docs')}" to local daemon ` +
+            'only and does nothing else. Same as ' +
+            `${chalk.whiteBright('ipfs add -r docs')}`
         )
     }
   )
-  .help().argv
+  .help()
+  .alias('h', 'help').argv
 
 function main() {
-  deploy({
-    updateDns: !argv.D,
-    open: argv.o,
-    // pinners: argv.p, TODO
-    // pinRemotely: !argv.P, TODO
+  const deployOptions = {
     publicDirPath: argv.path,
-    remote: {
-      siteDomain: argv.siteDomain,
+    copyPublicGatewayUrlToClipboard: !argv.noClipboard,
+    open: !argv.O,
+    localPinOnly: argv.P,
+    remotePinners: argv.p,
+    dnsProviders: argv.d,
+    siteDomain: argv.siteDomain,
+    credentials: {
       cloudflare: {
-        apiKey: argv.cloudflare.apiKey,
-        apiEmail: argv.cloudflare.apiEmail,
+        apiKey: argv.cloudflare && argv.cloudflare.apiKey,
+        apiEmail: argv.cloudflare && argv.cloudflare.apiEmail,
       },
       pinata: {
-        apiKey: argv.pinata.apiKey,
-        secretApiKey: argv.pinata.secretApiKey,
+        apiKey: argv.pinata && argv.pinata.apiKey,
+        secretApiKey: argv.pinata && argv.pinata.secretApiKey,
       },
     },
-  })
+  }
+  deploy(deployOptions)
 }
 
 main()

index.js

@@ -1,3 +1,4 @@
+const util = require('util')
 const IPFSFactory = require('ipfsd-ctl')
 const which = require('which')
 const clipboardy = require('clipboardy')
@@ -7,13 +8,20 @@ const updateCloudflareDnslink = require('dnslink-cloudflare')
 const ora = require('ora')
 const chalk = require('chalk')
 const openUrl = require('open')
+const _ = require('lodash')
 
-async function doUpdateDns({ siteDomain, cloudflare }, hash) {
+// # Pure functions
+function publicGatewayUrl(hash) {
+  return `https://ipfs.io/ipfs/${hash}`
+}
+
+// Effectful functions
+
+async function updateCloudflareDns(siteDomain, { apiEmail, apiKey }, hash) {
   const spinner = ora()
 
-  const { apiEmail, apiKey } = cloudflare
   if (!apiKey || !apiEmail || !siteDomain || !hash) {
-    throw new Error('Missing information for doUpdateDns()')
+    throw new Error('Missing information for updateCloudflareDns()')
   }
 
   const api = {
@@ -28,30 +36,31 @@ async function doUpdateDns({ siteDomain, cloudflare }, hash) {
   }
 
   try {
-    spinner.info(
+    spinner.start(
       `📡 Beaming new hash to DNS provider ${chalk.whiteBright(
         'Cloudflare'
       )}...`
     )
     const content = await updateCloudflareDnslink(api, opts)
     spinner.succeed('🙌 SUCCESS!')
-    spinner.info(`Updated TXT ${chalk.whiteBright(opts.record)} to:`)
-    spinner.info(`${chalk.whiteBright(content)}.`)
-    spinner.succeed('🌐 Your website is deployed now.')
+    spinner.info(`🔄 Updated DNS TXT ${chalk.whiteBright(opts.record)} to:`)
+    spinner.info(`🔗 ${chalk.whiteBright(content)}.`)
+    spinner.succeed('🌎 Your website is deployed now.')
   } catch (err) {
     console.error(err)
     process.exit(1)
   }
 }
 
 async function deploy({
-  updateDns = true,
+  publicDirPath,
+  copyPublicGatewayUrlToClipboard = false,
   open = false,
-  // pinners = ['pinata', 'infura'], TODO
-  // pinRemotely = true, TODO
-  publicDirPath = 'public',
-  remote = {
-    siteDomain,
+  localPinOnly = false,
+  remotePinners = ['infura'],
+  dnsProviders = [],
+  siteDomain,
+  credentials = {
     cloudflare: {
       apiEmail,
       apiKey,
@@ -69,106 +78,82 @@ async function deploy({
   const df = IPFSFactory.create({ exec: ipfsBinAbsPath })
 
   const spinner = ora()
-  spinner.start()
-  spinner.info('☎️  Connecting to local IPFS daemon...')
-
-  df.spawn({ disposable: false, init: false, start: false }, (err, ipfsd) => {
-    if (err) throw err
-
-    ipfsd.start([], (err2, ipfsClient) => {
-      if (err2) throw err2
-      // spinner.succeed('📶 Connected.')
-
-      spinner.info(
-        `💾 Adding and pinning ${chalk.blue(publicDirPath)} locally...`
-      )
-
-      ipfsClient.addFromFs(
-        publicDirPath,
-        { recursive: true },
-        (err3, localPinResult) => {
-          if (err3) {
-            spinner.fail(
-              "☠  Couldn't connect to local ipfs daemon. Is it running?"
-            )
-            throw err3
-          }
-
-          const { hash } = localPinResult[localPinResult.length - 1]
-          spinner.succeed(`🔗 Added locally as ${chalk.green(hash)}.`)
-
-          ipfsClient.id((err4, { addresses }) => {
-            if (err4) throw err4
-
-            const publicMultiaddresses = addresses.filter(
-              multiaddress =>
-                !multiaddress.match(/\/::1\//) &&
-                !multiaddress.match(/127\.0\.0\.1/) &&
-                !multiaddress.match(/192\.168/)
-            )
-
-            const pinataOptions = {
-              host_nodes: publicMultiaddresses,
-              pinataMetadata: {
-                name: remote.siteDomain,
-                keyvalues: {
-                  gitCommitHash: 'TODO',
-                },
-              },
-            }
-
-            const pinata = pinataSDK(
-              remote.pinata.apiKey,
-              remote.pinata.secretApiKey
-            )
-
-            spinner.info(
-              `📠 Requesting remote pin to ${chalk.whiteBright(
-                'pinata.cloud'
-              )}...`
-            )
-            pinata
-              .pinHashToIPFS(hash, pinataOptions)
-              .then(async _pinataPinResult => {
-                spinner.succeed("📌 It's pinned to Pinata now.")
-
-                try {
-                  spinner.info(
-                    `📠 Requesting remote pin to ${chalk.whiteBright(
-                      'infura.io'
-                    )}...`
-                  )
-                  const infuraResponse = await got(
-                    `https://ipfs.infura.io:5001/api/v0/pin/add?arg=${hash}` +
-                      '&recursive=true'
-                  )
-
-                  if (infuraResponse.statusCode === 200) {
-                    spinner.succeed("📌 It's pinned to Infura now.")
-                  } else {
-                    spinner.fail("Pinning to Infura didn't work.")
-                  }
-                } catch (e) {
-                  console.error(e)
-                }
-
-                clipboardy.writeSync(hash)
-                spinner.succeed(
-                  `📋 Hash ${chalk.green(hash)} copied to clipboard.`
-                )
-
-                if (updateDns) doUpdateDns(remote, hash)
-
-                if (open) openUrl(`https://${remote.siteDomain}`)
-              })
-              .catch(err5 => {
-                throw err5
-              })
-          })
-        }
-      )
-    })
+  spinner.start('☎️  Connecting to local IPFS daemon…')
+
+  const spawn = util.promisify(df.spawn.bind(df))
+  ipfsd = await spawn({ disposable: false, init: false, start: false })
+
+  const start = util.promisify(ipfsd.start.bind(ipfsd))
+  const ipfsClient = await start([])
+  spinner.succeed('☎️  Connected to local IPFS daemon.')
+
+  spinner.start('🔗 Pinning to local IPFS…')
+  const localPinResult = await ipfsClient.addFromFs(publicDirPath, {
+    recursive: true,
   })
+  const { hash } = localPinResult[localPinResult.length - 1]
+  spinner.succeed(`📌 Pinned locally as ${chalk.green(hash)}.`)
+
+  if (!localPinOnly && remotePinners.includes('pinata')) {
+    spinner.start(
+      `📠 Requesting remote pin to ${chalk.whiteBright('pinata.cloud')}…`
+    )
+    const { addresses } = await ipfsClient.id()
+
+    const publicMultiaddresses = addresses.filter(
+      multiaddress =>
+        !multiaddress.match(/\/::1\//) &&
+        !multiaddress.match(/127\.0\.0\.1/) &&
+        !multiaddress.match(/192\.168/)
+    )
+
+    const pinataOptions = {
+      host_nodes: publicMultiaddresses,
+      pinataMetadata: {
+        name: siteDomain,
+        // keyvalues: {
+        //   gitCommitHash: 'TODO',
+        // },
+      },
+    }
+
+    const pinata = pinataSDK(
+      credentials.pinata.apiKey,
+      credentials.pinata.secretApiKey
+    )
+
+    await pinata.pinHashToIPFS(hash, pinataOptions)
+
+    spinner.succeed("📌 It's pinned to Pinata now.")
+  }
+
+  if (!localPinOnly && remotePinners.includes('infura')) {
+    spinner.start(
+      `📠 Requesting remote pin to ${chalk.whiteBright('infura.io')}…`
+    )
+    const infuraResponse = await got(
+      `https://ipfs.infura.io:5001/api/v0/pin/add?arg=${hash}` +
+        '&recursive=true'
+    )
+
+    if (infuraResponse.statusCode === 200) {
+      spinner.succeed("📌 It's pinned to Infura now.")
+    } else {
+      spinner.fail("Pinning to Infura didn't work.")
+    }
+  }
+
+  if (copyPublicGatewayUrlToClipboard)
+    clipboardy.writeSync(publicGatewayUrl(hash))
+  spinner.succeed('📋 Public gateway URL copied to clipboard.')
+
+  if (dnsProviders.includes('cloudflare'))
+    await updateCloudflareDns(siteDomain, credentials.cloudflare, hash)
+
+  if (open && !localPinOnly && !_.isEmpty(dnsProviders))
+    openUrl(`https://${siteDomain}`)
+  if (open && (localPinOnly || _.isEmpty(dnsProviders)))
+    openUrl(publicGatewayUrl(hash))
 }
 
 module.exports = deploy