Refactoring prepare stage of functions deploy (#3067)

* refactoring prepare setp of functions deploy to use typescript, check for failure policies, and parse function triggers

* refactoring prepare setp of functions deploy to use typescript, check for failure policies, and parse function triggers

* commenting out functionNamesAreValid

* formats

src/deploy/functions/deploy.ts

@@ -3,22 +3,18 @@ import { setGracefulCleanup } from "tmp";
 
 import { functionsUploadRegion } from "../../api";
 import * as gcp from "../../gcp";
-import { logBullet, logSuccess, logWarning } from "../../utils";
-import * as prepareFunctionsUpload from "../../prepareFunctionsUpload";
+import { logSuccess, logWarning } from "../../utils";
 import { checkHttpIam } from "./checkIam";
 
 const GCP_REGION = functionsUploadRegion;
 
 setGracefulCleanup();
 
-async function uploadSource(
-  context: { projectId: string; uploadUrl?: string },
-  source: any // eslint-disable-line @typescript-eslint/no-explicit-any
-): Promise<void> {
+async function uploadSource(context: any): Promise<void> {
   const uploadUrl = await gcp.cloudfunctions.generateUploadUrl(context.projectId, GCP_REGION);
   context.uploadUrl = uploadUrl;
   const apiUploadUrl = uploadUrl.replace("https://storage.googleapis.com", "");
-  await gcp.storage.upload(source, apiUploadUrl);
+  await gcp.storage.upload(context.functionsSource, apiUploadUrl);
 }
 
 /**
@@ -30,26 +26,15 @@ async function uploadSource(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function deploy(context: any, options: any, payload: any): Promise<void> {
   if (options.config.get("functions")) {
-    logBullet(
-      clc.cyan.bold("functions:") +
-        " preparing " +
-        clc.bold(options.config.get("functions.source")) +
-        " directory for uploading..."
-    );
-
-    const source = await prepareFunctionsUpload(context, options);
     context.existingFunctions = await gcp.cloudfunctions.listAllFunctions(context.projectId);
-    payload.functions = {
-      triggers: options.config.get("functions.triggers"),
-    };
 
     await checkHttpIam(context, options, payload);
 
-    if (!source) {
+    if (!context.functionsSource) {
       return;
     }
     try {
-      await uploadSource(context, source);
+      await uploadSource(context);
       logSuccess(
         clc.green.bold("functions:") +
           " " +

src/deploy/functions/index.ts

@@ -1,4 +1,4 @@
-import * as prepare from "./prepare";
 import * as release from "./release";
+export { prepare } from "./prepare";
 export { deploy } from "./deploy";
-export { prepare, release };
+export { release };

src/deploy/functions/prepare.ts

@@ -0,0 +1,65 @@
+import * as _ from "lodash";
+import * as clc from "cli-color";
+
+import * as ensureApiEnabled from "../../ensureApiEnabled";
+import * as functionsConfig from "../../functionsConfig";
+import * as getProjectId from "../../getProjectId";
+import { logBullet } from "../../utils";
+import { getRuntimeChoice } from "../../parseRuntimeAndValidateSDK";
+import { getFunctionsInfo, promptForFailurePolicies } from "../../functionsDeployHelper";
+import * as prepareFunctionsUpload from "../../prepareFunctionsUpload";
+import * as validate from "./validate";
+import { checkRuntimeDependencies } from "./checkRuntimeDependencies";
+
+export async function prepare(context: any, options: any, payload: any): Promise<void> {
+  if (!options.config.has("functions")) {
+    return;
+  }
+
+  const sourceDirName = options.config.get("functions.source");
+  const sourceDir = options.config.path(sourceDirName);
+  const projectDir = options.config.projectDir;
+  const projectId = getProjectId(options);
+
+  // Check what runtime to use, first in firebase.json, then in 'engines' field.
+  const runtimeFromConfig = options.config.get("functions.runtime");
+  context.runtimeChoice = getRuntimeChoice(sourceDir, runtimeFromConfig);
+
+  // Check that all necessary APIs are enabled.
+  const checkAPIsEnabled = await Promise.all([
+    ensureApiEnabled.ensure(options.project, "cloudfunctions.googleapis.com", "functions"),
+    ensureApiEnabled.check(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true),
+    checkRuntimeDependencies(projectId, context.runtimeChoice),
+  ]);
+  _.set(context, "runtimeConfigEnabled", checkAPIsEnabled[1]);
+
+  // Get the Firebase Config.
+  const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
+  _.set(context, "firebaseConfig", firebaseConfig);
+
+  // Prepare the functions directory for upload, and set context.triggers.
+  logBullet(
+    clc.cyan.bold("functions:") +
+      " preparing " +
+      clc.bold(options.config.get("functions.source")) +
+      " directory for uploading..."
+  );
+  const source = await prepareFunctionsUpload(context, options);
+  _.set(context, "functionsSource", source);
+
+  // Get a list of CloudFunctionTriggers, with duplicates for each region.
+  payload.functions = {};
+  payload.functions.triggers = getFunctionsInfo(
+    options.config.get("functions.triggers"),
+    projectId
+  );
+
+  // Validate the function code that is being deployed.
+  validate.functionsDirectoryExists(options, sourceDirName);
+  // validate.functionNamesAreValid(payload.functionNames);
+  // TODO: This doesn't do anything meaningful right now because payload.functions is not defined
+  validate.packageJsonIsValid(sourceDirName, sourceDir, projectDir, !!runtimeFromConfig);
+
+  // Display a warning and prompt if any functions have failurePolicies.
+  await promptForFailurePolicies(options, payload.functions.triggers);
+}

src/deploy/functions/release.js

@@ -135,7 +135,7 @@ module.exports = function (context, options, payload) {
   failedDeployments = [];
 
   var appEngineLocation = getAppEngineLocation(context.firebaseConfig);
-  var functionsInfo = helper.getFunctionsInfo(payload.functions.triggers, projectId);
+  var functionsInfo = payload.functions.triggers;
   functionsInfo = functionsInfo.map((fn) => {
     if (
       fn.eventTrigger &&
@@ -154,49 +154,9 @@ module.exports = function (context, options, payload) {
   var deleteReleaseNames;
   var existingScheduledFunctions;
 
-  // Collect all the functions that have a retry policy
-  var failurePolicyFunctions = functionsInfo.filter((fn) => {
-    return !!fn.failurePolicy;
-  });
-
-  let proceedPrompt = Promise.resolve(true);
-  if (failurePolicyFunctions.length) {
-    var failurePolicyFunctionLabels = failurePolicyFunctions.map((fn) => {
-      return helper.getFunctionLabel(_.get(fn, "name"));
-    });
-    var retryMessage =
-      "The following functions will be retried in case of failure: " +
-      clc.bold(failurePolicyFunctionLabels.join(", ")) +
-      ". " +
-      "Retried executions are billed as any other execution, and functions are retried repeatedly until they either successfully execute or the maximum retry period has elapsed, which can be up to 7 days. " +
-      "For safety, you might want to ensure that your functions are idempotent; see https://firebase.google.com/docs/functions/retries to learn more.";
-
-    utils.logLabeledWarning("functions", retryMessage);
-
-    if (options.nonInteractive && !options.force) {
-      throw new FirebaseError("Pass the --force option to deploy functions with a failure policy", {
-        exit: 1,
-      });
-    } else if (!options.nonInteractive) {
-      proceedPrompt = promptOnce({
-        type: "confirm",
-        name: "confirm",
-        default: false,
-        message: "Would you like to proceed with deployment?",
-      });
-    }
-  }
-
   delete payload.functions;
 
-  return proceedPrompt
-    .then((proceed) => {
-      if (!proceed) {
-        throw new FirebaseError("Deployment canceled.", { exit: 1 });
-      }
-
-      return Promise.resolve(context.existingFunctions);
-    })
+  return Promise.resolve(context.existingFunctions)
     .then(function (existingFunctions) {
       var pluckName = function (functionObject) {
         return _.get(functionObject, "name"); // e.g.'projects/proj1/locations/us-central1/functions/func'

src/functionsDeployHelper.ts

@@ -7,6 +7,7 @@ import * as track from "./track";
 import * as utils from "./utils";
 import * as cloudfunctions from "./gcp/cloudfunctions";
 import * as pollOperations from "./pollOperations";
+import { promptOnce } from "./prompt";
 
 // TODO: Get rid of this when switching to use operation-poller.
 export interface Operation {
@@ -267,3 +268,49 @@ export function pollDeploys(
     throw new FirebaseError("Failed to get status of functions deployments.");
   }
 }
+
+/**
+ * Checks if a deployment will create any functions with a failure policy.
+ * If there are any, prompts the user to acknowledge the retry behavior.
+ * @param options
+ * @param functions A list of all functions in the deployment
+ */
+export async function promptForFailurePolicies(
+  options: any,
+  functions: CloudFunctionTrigger[]
+): Promise<void> {
+  // Collect all the functions that have a retry policy
+  const failurePolicyFunctions = functions.filter((fn: CloudFunctionTrigger) => {
+    return !!fn.failurePolicy;
+  });
+
+  if (failurePolicyFunctions.length) {
+    const failurePolicyFunctionLabels = failurePolicyFunctions.map((fn: CloudFunctionTrigger) => {
+      return getFunctionLabel(_.get(fn, "name"));
+    });
+    const retryMessage =
+      "The following functions will be retried in case of failure: " +
+      clc.bold(failurePolicyFunctionLabels.join(", ")) +
+      ". " +
+      "Retried executions are billed as any other execution, and functions are retried repeatedly until they either successfully execute or the maximum retry period has elapsed, which can be up to 7 days. " +
+      "For safety, you might want to ensure that your functions are idempotent; see https://firebase.google.com/docs/functions/retries to learn more.";
+
+    utils.logLabeledWarning("functions", retryMessage);
+
+    if (options.nonInteractive && !options.force) {
+      throw new FirebaseError("Pass the --force option to deploy functions with a failure policy", {
+        exit: 1,
+      });
+    } else if (!options.nonInteractive) {
+      const proceed = await promptOnce({
+        type: "confirm",
+        name: "confirm",
+        default: false,
+        message: "Would you like to proceed with deployment?",
+      });
+      if (!proceed) {
+        throw new FirebaseError("Deployment canceled.", { exit: 1 });
+      }
+    }
+  }
+}