functionsConfig.ts

import * as _ from "lodash";
import * as clc from "colorette";

import { firebaseApiOrigin } from "./api";
import { Client } from "./apiv2";
import { ensure as ensureApiEnabled } from "./ensureApiEnabled";
import { FirebaseError } from "./error";
import { needProjectId } from "./projectUtils";
import * as runtimeconfig from "./gcp/runtimeconfig";
import * as args from "./deploy/functions/args";
import * as experiments from "./experiments";
import { logWarningToStderr } from "./utils";

export const RESERVED_NAMESPACES = ["firebase"];

const apiClient = new Client({ urlPrefix: firebaseApiOrigin() });

const LEGACY_RUNTIME_CONFIG_EXPERIMENT = "legacyRuntimeConfigCommands";

const FUNCTIONS_CONFIG_DEPRECATION_MESSAGE = `DEPRECATION NOTICE: Action required before March 2026

The functions.config() API and the Cloud Runtime Config service are deprecated. Deploys that rely on functions.config() will fail once Runtime Config shuts down in March 2026.

The legacy functions:config:* CLI commands are deprecated and will be removed before March 2026.

Learn how to migrate from functions.config() to the params package:

https://firebase.google.com/docs/functions/config-env#migrate-config

To convert existing functions.config() values to params, try the interactive migration command:

  firebase functions:config:export
`;

const LEGACY_GUIDANCE_MESSAGE = `${FUNCTIONS_CONFIG_DEPRECATION_MESSAGE}

To run this legacy command temporarily, run the following command and try again:

  firebase experiments:enable ${LEGACY_RUNTIME_CONFIG_EXPERIMENT}
`;

export function getFunctionsConfigDeprecationMessage(): string {
  return FUNCTIONS_CONFIG_DEPRECATION_MESSAGE;
}

export function logFunctionsConfigDeprecationWarning(): void {
  logWarningToStderr(FUNCTIONS_CONFIG_DEPRECATION_MESSAGE);
}

export function ensureLegacyRuntimeConfigCommandsEnabled(): void {
  if (experiments.isEnabled(LEGACY_RUNTIME_CONFIG_EXPERIMENT)) {
    return;
  }
  throw new FirebaseError(LEGACY_GUIDANCE_MESSAGE, { exit: 1 });
}

interface Id {
  config: string;
  variable: string;
}
function keyToIds(key: string): Id {
  const keyParts = key.split(".");
  const variable = keyParts.slice(1).join("/");
  return {
    config: keyParts[0],
    variable: variable,
  };
}

function setVariable(
  projectId: string,
  configId: string,
  varPath: string,
  val: string | object,
): Promise<any> {
  if (configId === "" || varPath === "") {
    const msg = "Invalid argument, each config value must have a 2-part key (e.g. foo.bar).";
    throw new FirebaseError(msg);
  }
  return runtimeconfig.variables.set(projectId, configId, varPath, val);
}

function isReservedNamespace(id: Id) {
  return RESERVED_NAMESPACES.some((reserved) => {
    return id.config.toLowerCase().startsWith(reserved);
  });
}

export async function ensureApi(options: any): Promise<void> {
  const projectId = needProjectId(options);
  return ensureApiEnabled(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true);
}

export function varNameToIds(varName: string): Id {
  return {
    config: varName.match(new RegExp("/configs/(.+)/variables/"))![1],
    variable: varName.match(new RegExp("/variables/(.+)"))![1],
  };
}

export function idsToVarName(projectId: string, configId: string, varId: string): string {
  return ["projects", projectId, "configs", configId, "variables", varId].join("/");
}

// TODO(inlined): Yank and inline into Fabricator
export function getAppEngineLocation(config: any): string {
  let appEngineLocation = config.locationId;
  if (appEngineLocation && appEngineLocation.match(/[^\d]$/)) {
    // For some regions, such as us-central1, the locationId has the trailing digit cut off
    appEngineLocation = appEngineLocation + "1";
  }
  return appEngineLocation || "us-central1";
}

export async function getFirebaseConfig(options: any): Promise<args.FirebaseConfig> {
  const projectId = needProjectId(options);
  const response = await apiClient.get<args.FirebaseConfig>(
    `/v1beta1/projects/${projectId}/adminSdkConfig`,
  );
  return response.body;
}

// If you make changes to this function, run "node scripts/test-functions-config.js"
// to ensure that nothing broke.
export async function setVariablesRecursive(
  projectId: string,
  configId: string,
  varPath: string,
  val: string | { [key: string]: any },
): Promise<any> {
  let parsed = val;
  if (typeof val === "string") {
    try {
      // Only attempt to parse 'val' if it is a String (takes care of unparsed JSON, numbers, quoted string, etc.)
      parsed = JSON.parse(val);
    } catch (e: any) {
      // 'val' is just a String
    }
  }
  // If 'parsed' is object, call again
  if (typeof parsed === "object" && parsed !== null) {
    return Promise.all(
      Object.entries(parsed).map(([key, item]) => {
        const newVarPath = varPath ? [varPath, key].join("/") : key;
        return setVariablesRecursive(projectId, configId, newVarPath, item);
      }),
    );
  }

  // 'val' wasn't more JSON, i.e. is a leaf node; set and return
  return setVariable(projectId, configId, varPath, val);
}

export async function materializeConfig(configName: string, output: any): Promise<any> {
  const materializeVariable = async function (varName: string) {
    const variable = await runtimeconfig.variables.get(varName);
    const id = varNameToIds(variable.name);
    const key = id.config + "." + id.variable.split("/").join(".");
    _.set(output, key, variable.text);
  };

  const traverseVariables = async function (variables: { name: string }[]) {
    return Promise.all(
      variables.map((variable) => {
        return materializeVariable(variable.name);
      }),
    );
  };

  const variables = await runtimeconfig.variables.list(configName);
  await traverseVariables(variables);
  return output;
}

export async function materializeAll(projectId: string): Promise<Record<string, any>> {
  const output = {};
  const configs = await runtimeconfig.configs.list(projectId);
  if (!Array.isArray(configs) || !configs.length) {
    return output;
  }
  await Promise.all(
    configs.map<Promise<any> | undefined>((config: any) => {
      if (config.name.match(new RegExp("configs/firebase"))) {
        // ignore firebase config
        return;
      }
      return materializeConfig(config.name, output);
    }),
  );
  return output;
}

interface ParsedArg {
  configId: string;
  varId: string;
  val?: string;
}

export function parseSetArgs(args: string[]): ParsedArg[] {
  const parsed: ParsedArg[] = [];
  for (const arg of args) {
    const parts = arg.split("=");
    const key = parts[0];
    if (parts.length < 2) {
      throw new FirebaseError("Invalid argument " + clc.bold(arg) + ", must be in key=val format");
    }
    if (/[A-Z]/.test(key)) {
      throw new FirebaseError("Invalid config name " + clc.bold(key) + ", cannot use upper case.");
    }

    const id = keyToIds(key);
    if (isReservedNamespace(id)) {
      throw new FirebaseError("Cannot set to reserved namespace " + clc.bold(id.config));
    }

    const val = parts.slice(1).join("="); // So that someone can have '=' within a variable value
    parsed.push({
      configId: id.config,
      varId: id.variable,
      val: val,
    });
  }
  return parsed;
}

export function parseUnsetArgs(args: string[]): ParsedArg[] {
  const parsed: ParsedArg[] = [];
  let splitArgs: string[] = [];
  for (const arg of args) {
    splitArgs = Array.from(new Set([...splitArgs, ...arg.split(",")]));
  }

  for (const key of splitArgs) {
    const id = keyToIds(key);
    if (isReservedNamespace(id)) {
      throw new FirebaseError("Cannot unset reserved namespace " + clc.bold(id.config));
    }

    parsed.push({
      configId: id.config,
      varId: id.variable,
    });
  }
  return parsed;
}