netlify account flow

Author: jjallaire

src/command/publish/cmd.ts

@@ -5,13 +5,17 @@
 *
 */
 
+import { error } from "log/mod.ts";
+
+import { prompt } from "cliffy/prompt/mod.ts";
 import { Command } from "cliffy/command/mod.ts";
 import { Select } from "cliffy/prompt/select.ts";
 
 import { PublishOptions } from "./provider.ts";
 
 import { ghpagesProvider } from "./ghpages.ts";
 import { netlifyProvider } from "./netlify.ts";
+import { exitWithCleanup } from "../../core/cleanup.ts";
 
 const kPublishProviders = [netlifyProvider, ghpagesProvider];
 
@@ -23,6 +27,10 @@ export const publishCommand = withProviders(
       "--no-render",
       "Do not render before publishing.",
     )
+    .option(
+      "--no-prompt",
+      "Do not prompt to confirm publishing destination",
+    )
     .description(
       "Publish a document or project to a variety of destinations.",
       // deno-lint-ignore no-explicit-any
@@ -31,21 +39,34 @@ export const publishCommand = withProviders(
       const publishOptions: PublishOptions = {
         path: path || Deno.cwd(),
         render: !!options.render,
+        prompt: !!options.prompt,
       };
 
+      // can't call base publish with no prompot
+      if (!publishOptions.prompt) {
+        error(
+          "You must specify an explicit provider (e.g. 'netlify') with --no-prompt",
+        );
+        exitWithCleanup(1);
+      }
+
       // select provider
-      const name: string = await Select.prompt({
+      const result = await prompt([{
+        name: "destination",
         message: "Select destination:",
         options: kPublishProviders.map((provider) => ({
           name: provider.description,
           value: provider.name,
         })),
-      });
+        type: Select,
+      }]);
 
       // call provider
-      const provider = findProvider(name);
-      if (provider) {
-        provider.configure(publishOptions);
+      if (result.destination) {
+        const provider = findProvider(result.destination);
+        if (provider) {
+          await provider.configure(publishOptions);
+        }
       }
     }),
 );
@@ -63,6 +84,10 @@ function withProviders(command: Command<any>): Command<any> {
           .option(
             "--no-render",
             "Do not render before publishing.",
+          )
+          .option(
+            "--no-prompt",
+            "Do not prompt to confirm publishing destination",
           ),
       ),
     );

src/command/publish/ghpages.ts

@@ -19,6 +19,7 @@ export const ghpagesProvider: PublishProvider = {
         ghpagesConfigure({
           path: path || Deno.cwd(),
           render: !!options.render,
+          prompt: !!options.prompt,
         });
       });
   },

src/command/publish/netlify.ts

@@ -5,10 +5,23 @@
 *
 */
 
+import { error } from "log/mod.ts";
+
 import { Command } from "cliffy/command/mod.ts";
+import { prompt } from "cliffy/prompt/mod.ts";
+import { Select, SelectOption } from "cliffy/prompt/select.ts";
+import { Confirm } from "cliffy/prompt/confirm.ts";
+import {
+  authorizeNetlifyAccessToken,
+  kNetlifyAuthTokenVar,
+  netlifyAccessToken,
+  netlifyEnvironmentAuthToken,
+} from "../../publish/netlify/account.ts";
 import { netlifyPublish } from "../../publish/netlify/netlify.ts";
 
 import { PublishOptions, PublishProvider } from "./provider.ts";
+import { exitWithCleanup } from "../../core/cleanup.ts";
+import { AccessToken, ApiError } from "../../publish/netlify/api/index.ts";
 
 export const netlifyProvider: PublishProvider = {
   name: "netlify",
@@ -20,14 +33,149 @@ export const netlifyProvider: PublishProvider = {
         await netlifyConfigure({
           path: path || Deno.cwd(),
           render: !!options.render,
+          prompt: !!options.prompt,
         });
       });
   },
   configure: netlifyConfigure,
 };
 
-async function netlifyConfigure(options: PublishOptions) {
-  console.log("netlify");
-  console.log(options);
-  await netlifyPublish();
+const kEnvToken = "env-token";
+const kAuthorizedToken = "authorized-token";
+const kAuthorize = "authorize";
+
+async function netlifyConfigure(options: PublishOptions): Promise<void> {
+  // see what tyep of token we are going to use
+  let token: string | undefined;
+  let tokenType: "env-token" | "authorized-token" | undefined;
+  const envToken = netlifyEnvironmentAuthToken();
+  const accessToken = netlifyAccessToken();
+  const authorizedToken = accessToken?.access_token;
+
+  // if we aren't prompting then we need to have one at the ready
+  if (!options.prompt) {
+    token = envToken || authorizedToken;
+    if (!token) {
+      error(
+        `No existing account available (account required for publish with --no-prompt)`,
+      );
+    }
+  } else {
+    // build list of selection options
+
+    const options: SelectOption[] = [];
+    if (envToken) {
+      options.push({
+        name: `${kNetlifyAuthTokenVar}`,
+        value: kEnvToken,
+      });
+    }
+    if (authorizedToken) {
+      options.push({
+        name: `${accessToken.email!}`,
+        value: kAuthorizedToken,
+      });
+    }
+    if (options.length > 0) {
+      options.push({
+        name: "Use another account...",
+        value: kAuthorize,
+      });
+
+      const result = await prompt([{
+        name: "token",
+        message: "Netlify account:",
+        options,
+        type: Select,
+      }]);
+      switch (result.token) {
+        case kEnvToken: {
+          token = envToken;
+          tokenType = kEnvToken;
+          break;
+        }
+        case kAuthorizedToken: {
+          token = authorizedToken;
+          tokenType = kAuthorizedToken;
+          break;
+        }
+        case kAuthorize: {
+          tokenType = kAuthorizedToken;
+        }
+      }
+    }
+
+    // if we don't have a token yet we need to authorize
+    if (!token) {
+      const result = await prompt([{
+        name: "confirmed",
+        message: "Authorize account",
+        default: true,
+        hint:
+          "In order to publish to Netlify with Quarto you need to authorize your account.\n" +
+          "   Please be sure you are logged into the correct Netlify account in your default\n" +
+          "   web browser, then press Enter to authorize.",
+        type: Confirm,
+      }]);
+      if (!result.confirmed) {
+        exitWithCleanup(1);
+      }
+
+      // do the authorization
+      token = (await authorizeNetlifyAccessToken())?.access_token;
+    }
+  }
+
+  // publish if we have a token
+  if (token) {
+    try {
+      await netlifyPublish({
+        token,
+      });
+    } catch (error) {
+      // attempt to recover from unauthorized
+      if (error instanceof ApiError && error.status === 401) {
+        await handleUnauthorized(tokenType!, options, accessToken);
+      } else {
+        throw error;
+      }
+    }
+  }
+}
+
+async function handleUnauthorized(
+  tokenType: string,
+  options: PublishOptions,
+  accessToken?: AccessToken,
+) {
+  if (tokenType === kEnvToken) {
+    error(
+      `Unable to authenticate with the provided ${kNetlifyAuthTokenVar}. Please be sure this token is valid.`,
+    );
+    exitWithCleanup(1);
+  } else if (tokenType === kAuthorizedToken && accessToken) {
+    const result = await prompt([{
+      name: "confirmed",
+      message: "Re-authorize account",
+      default: true,
+      hint:
+        `The authorization saved for account ${accessToken.email} is no longer valid.\n` +
+        "   Please be sure you are logged into the correct Netlify account in your\n" +
+        "   default web browser, then press Enter to re-authorize.",
+      type: Confirm,
+    }]);
+    if (!result.confirmed) {
+      exitWithCleanup(1);
+    }
+
+    // do the authorization then re-try
+    if ((await authorizeNetlifyAccessToken())) {
+      await netlifyConfigure(options);
+      return;
+    }
+  }
+
+  // default error
+  error("Unable to publish to Netlify (unauthorized)");
+  exitWithCleanup(1);
 }

src/command/publish/provider.ts

@@ -10,6 +10,7 @@ import { Command } from "cliffy/command/mod.ts";
 export interface PublishOptions {
   path: string;
   render: boolean;
+  prompt: boolean;
 }
 
 export interface PublishProvider {

src/publish/netlify/account.ts

@@ -0,0 +1,97 @@
+/*
+* accounts.ts
+*
+* Copyright (C) 2020 by RStudio, PBC
+*
+*/
+
+import { join } from "path/mod.ts";
+import { ensureDirSync, existsSync } from "fs/mod.ts";
+
+import { quartoDataDir } from "../../core/appdirs.ts";
+
+import { AccessToken, NetlifyClient, Ticket } from "./api/index.ts";
+import { quartoConfig } from "../../core/quarto.ts";
+import { openUrl } from "../../core/shell.ts";
+import { sleep } from "../../core/wait.ts";
+
+export const kNetlifyAuthTokenVar = "NETLIFY_AUTH_TOKEN";
+
+export function netlifyEnvironmentAuthToken() {
+  return Deno.env.get(kNetlifyAuthTokenVar);
+}
+
+export function netlifyAccessToken(): AccessToken | undefined {
+  const tokenPath = netlifyAccessTokenPath();
+  if (existsSync(tokenPath)) {
+    const token = JSON.parse(Deno.readTextFileSync(tokenPath)) as AccessToken;
+    return token;
+  } else {
+    return undefined;
+  }
+}
+
+export async function authorizeNetlifyAccessToken(): Promise<
+  AccessToken | undefined
+> {
+  // create ticket for authorization
+  const client = new NetlifyClient({});
+  const clientId = (await quartoConfig.dotenv())["NETLIFY_APP_CLIENT_ID"];
+  const ticket = await client.ticket.createTicket({
+    clientId,
+  }) as unknown as Ticket;
+  await openUrl(
+    `https://app.netlify.com/authorize?response_type=ticket&ticket=${ticket.id}`,
+  );
+
+  // poll for ticket to be authoried
+  let authorizedTicket: Ticket | undefined;
+  const checkTicket = async () => {
+    const t = await client.ticket.showTicket({ ticketId: ticket.id! });
+    if (t.authorized) {
+      authorizedTicket = t;
+    }
+    return Boolean(t.authorized);
+  };
+  const pollingStart = Date.now();
+  const kPollingTimeout = 60 * 1000;
+  const kPollingInterval = 500;
+  while ((Date.now() - pollingStart) < kPollingTimeout) {
+    if (await checkTicket()) {
+      break;
+    }
+    await sleep(kPollingInterval);
+  }
+  if (authorizedTicket) {
+    // exechange ticket for the token
+    const accessToken = await client.accessToken
+      .exchangeTicket({
+        ticketId: authorizedTicket!.id!,
+      }) as unknown as AccessToken;
+
+    // save the token
+    writeNetlifyAccessToken(accessToken);
+
+    // return it
+    return accessToken;
+  } else {
+    return undefined;
+  }
+}
+
+function writeNetlifyAccessToken(token: AccessToken) {
+  Deno.writeTextFileSync(
+    netlifyAccessTokenPath(),
+    JSON.stringify(token, undefined, 2),
+  );
+}
+
+function accountsDataDir() {
+  return quartoDataDir("accounts");
+}
+
+function netlifyAccessTokenPath() {
+  const dir = join(accountsDataDir(), "netlify");
+  ensureDirSync(dir);
+  return join(dir, "token.json");
+}