Make FirebaseConfig properties available as internal parameters (#4970)

Author: Berlioz

src/deploy/functions/build.ts

@@ -6,6 +6,7 @@ import { previews } from "../../previews";
 import { FirebaseError } from "../../error";
 import { assertExhaustive, mapObject, nullsafeVisitor } from "../../functional";
 import { UserEnvsOpts, writeUserEnvs } from "../../functions/env";
+import { FirebaseConfig } from "./args";
 
 /* The union of a customer-controlled deployment and potentially deploy-time defined parameters */
 export interface Build {
@@ -274,24 +275,24 @@ export type Endpoint = Triggered & {
  */
 export async function resolveBackend(
   build: Build,
+  firebaseConfig: FirebaseConfig,
   userEnvOpt: UserEnvsOpts,
   userEnvs: Record<string, string>,
   nonInteractive?: boolean
 ): Promise<{ backend: backend.Backend; envs: Record<string, params.ParamValue> }> {
-  const projectId = userEnvOpt.projectId;
   let paramValues: Record<string, params.ParamValue> = {};
   if (previews.functionsparams) {
     paramValues = await params.resolveParams(
       build.params,
-      projectId,
+      firebaseConfig,
       envWithTypes(build.params, userEnvs),
       nonInteractive
     );
 
     const toWrite: Record<string, string> = {};
     for (const paramName of Object.keys(paramValues)) {
       const paramValue = paramValues[paramName];
-      if (Object.prototype.hasOwnProperty.call(userEnvs, paramName) || paramValue.secret) {
+      if (Object.prototype.hasOwnProperty.call(userEnvs, paramName) || paramValue.internal) {
         continue;
       }
       toWrite[paramName] = paramValue.toString();

src/deploy/functions/params.ts

@@ -6,6 +6,7 @@ import { assertExhaustive, partition } from "../../functional";
 import * as secretManager from "../../gcp/secretManager";
 import { listBuckets } from "../../gcp/storage";
 import { isCelExpression, resolveExpression } from "./cel";
+import { FirebaseConfig } from "./args";
 
 // A convinience type containing options for Prompt's select
 interface ListItem {
@@ -104,12 +105,21 @@ type ParamBase<T extends string | number | boolean> = {
   input?: ParamInput<T>;
 };
 
+/**
+ * Determines whether an Input field value can be coerced to TextInput.
+ */
 export function isTextInput<T>(input: ParamInput<T>): input is TextInput<T> {
   return {}.hasOwnProperty.call(input, "text");
 }
+/**
+ * Determines whether an Input field value can be coerced to SelectInput.
+ */
 export function isSelectInput<T>(input: ParamInput<T>): input is SelectInput<T> {
   return {}.hasOwnProperty.call(input, "select");
 }
+/**
+ * Determines whether an Input field value can be coerced to ResourceInput.
+ */
 export function isResourceInput<T>(input: ParamInput<T>): input is ResourceInput {
   return {}.hasOwnProperty.call(input, "resource");
 }
@@ -199,7 +209,7 @@ export class ParamValue {
 
   constructor(
     private readonly rawValue: string,
-    readonly secret: boolean,
+    readonly internal: boolean,
     types: { string?: boolean; boolean?: boolean; number?: boolean }
   ) {
     this.legalString = types.string || false;
@@ -236,8 +246,7 @@ function resolveDefaultCEL(
 ): RawParamValue {
   const deps = dependenciesCEL(expr);
   const allDepsFound = deps.every((dep) => !!currentEnv[dep]);
-  const dependsOnSecret = deps.some((dep) => currentEnv[dep].secret);
-  if (!allDepsFound || dependsOnSecret) {
+  if (!allDepsFound) {
     throw new FirebaseError(
       "Build specified parameter with un-resolvable default value " +
         expr +
@@ -288,11 +297,11 @@ function canSatisfyParam(param: Param, value: RawParamValue): boolean {
  */
 export async function resolveParams(
   params: Param[],
-  projectId: string,
+  firebaseConfig: FirebaseConfig,
   userEnvs: Record<string, ParamValue>,
   nonInteractive?: boolean
 ): Promise<Record<string, ParamValue>> {
-  const paramValues: Record<string, ParamValue> = {};
+  const paramValues: Record<string, ParamValue> = populateDefaultParams(firebaseConfig);
 
   // TODO(vsfan@): should we ever reject param values from .env files based on the appearance of the string?
   const [resolved, outstanding] = partition(params, (param) => {
@@ -304,7 +313,7 @@ export async function resolveParams(
 
   const [needSecret, needPrompt] = partition(outstanding, (param) => param.type === "secret");
   for (const param of needSecret) {
-    await handleSecret(param as SecretParam, projectId);
+    await handleSecret(param as SecretParam, firebaseConfig.projectId);
   }
 
   if (nonInteractive && needPrompt.length > 0) {
@@ -326,12 +335,41 @@ export async function resolveParams(
         "Parameter " + param.name + " has default value " + paramDefault + " of wrong type"
       );
     }
-    paramValues[param.name] = await promptParam(param, projectId, paramDefault);
+    paramValues[param.name] = await promptParam(param, firebaseConfig.projectId, paramDefault);
   }
 
   return paramValues;
 }
 
+function populateDefaultParams(config: FirebaseConfig): Record<string, ParamValue> {
+  const defaultParams: Record<string, ParamValue> = {};
+  if (config.databaseURL !== "") {
+    defaultParams["DATABASE_URL"] = new ParamValue(config.databaseURL, true, {
+      string: true,
+      boolean: false,
+      number: false,
+    });
+  }
+  defaultParams["PROJECT_ID"] = new ParamValue(config.projectId, true, {
+    string: true,
+    boolean: false,
+    number: false,
+  });
+  defaultParams["GCLOUD_PROJECT"] = new ParamValue(config.projectId, true, {
+    string: true,
+    boolean: false,
+    number: false,
+  });
+  if (config.storageBucket !== "") {
+    defaultParams["STORAGE_BUCKET"] = new ParamValue(config.storageBucket, true, {
+      string: true,
+      boolean: false,
+      number: false,
+    });
+  }
+  return defaultParams;
+}
+
 /**
  * Handles a SecretParam by checking for the presence of a corresponding secret
  * in Cloud Secrets Manager. If not present, we currently ask the user to

src/deploy/functions/prepare.ts

@@ -118,6 +118,7 @@ export async function prepare(
     const wantBuild: build.Build = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
     const { backend: wantBackend, envs: resolvedEnvs } = await build.resolveBackend(
       wantBuild,
+      firebaseConfig,
       userEnvOpt,
       userEnvs,
       options.nonInteractive
@@ -129,6 +130,7 @@ export async function prepare(
       const envValue = resolvedEnvs[envName]?.toString();
       if (
         envValue &&
+        !resolvedEnvs[envName].internal &&
         !Object.prototype.hasOwnProperty.call(wantBackend.environmentVariables, envName)
       ) {
         wantBackend.environmentVariables[envName] = envValue;

src/emulator/functionsEmulator.ts

@@ -455,10 +455,11 @@ export class FunctionsEmulator implements EmulatorInstance {
       await runtimeDelegate.build();
       logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
       // Don't include user envs when parsing triggers, but we need some of the options for handling params
+      const firebaseConfig = this.getFirebaseConfig();
       const environment = {
         ...this.getSystemEnvs(),
         ...this.getEmulatorEnvs(),
-        FIREBASE_CONFIG: this.getFirebaseConfig(),
+        FIREBASE_CONFIG: firebaseConfig,
         ...emulatableBackend.env,
       };
       const userEnvOpt: functionsEnv.UserEnvsOpts = {
@@ -467,7 +468,12 @@ export class FunctionsEmulator implements EmulatorInstance {
         projectAlias: this.args.projectAlias,
       };
       const discoveredBuild = await runtimeDelegate.discoverBuild(runtimeConfig, environment);
-      const resolution = await resolveBackend(discoveredBuild, userEnvOpt, environment);
+      const resolution = await resolveBackend(
+        discoveredBuild,
+        JSON.parse(firebaseConfig),
+        userEnvOpt,
+        environment
+      );
       const discoveredBackend = resolution.backend;
       const endpoints = backend.allEndpoints(discoveredBackend);
       prepareEndpoints(endpoints);