feat: Add validation for function prefixes and source/prefix pairs

This change introduces two new validation rules for function configurations in `firebase.json`:

1.  The `prefix` property, if specified, must only contain lowercase letters, numbers, and hyphens.
2.  The combination of `source` and `prefix` must be unique across all function configurations.

These changes ensure that function deployments with prefixes are valid and that there are no conflicts when deploying multiple functions from the same source directory.

Author: taeold

src/functions/projectConfig.spec.ts

@@ -45,18 +45,37 @@ describe("projectConfig", () => {
     it("passes validation for multi-instance config with same source", () => {
       const config = [
         { source: "foo", codebase: "bar" },
-        { source: "foo", codebase: "baz" },
+        { source: "foo", codebase: "baz", prefix: "prefix-two" },
       ];
       expect(projectConfig.validate(config as projectConfig.NormalizedConfig)).to.deep.equal(
         config,
       );
     });
 
-    it("fails validation for multi-instance config with missing codebase", () => {
-      const config = [{ source: "foo", codebase: "bar" }, { source: "foo" }];
+    it("passes validation for multi-instance config with one missing codebase", () => {
+      const config = [{ source: "foo", codebase: "bar", prefix: "bar-prefix" }, { source: "foo" }];
+      const expected = [
+        { source: "foo", codebase: "bar", prefix: "bar-prefix" },
+        { source: "foo", codebase: "default" },
+      ];
+      expect(projectConfig.validate(config as projectConfig.NormalizedConfig)).to.deep.equal(
+        expected,
+      );
+    });
+
+    it("fails validation for multi-instance config with missing codebase and a default codebase", () => {
+      const config = [{ source: "foo", codebase: "default" }, { source: "foo" }];
       expect(() => projectConfig.validate(config as projectConfig.NormalizedConfig)).to.throw(
         FirebaseError,
-        /Each functions config must have a unique 'codebase' field/,
+        /functions.codebase must be unique but 'default' was used more than once./,
+      );
+    });
+
+    it("fails validation for multi-instance config with multiple missing codebases", () => {
+      const config = [{ source: "foo" }, { source: "foo" }];
+      expect(() => projectConfig.validate(config as projectConfig.NormalizedConfig)).to.throw(
+        FirebaseError,
+        /functions.codebase must be unique but 'default' was used more than once./,
       );
     });
 
@@ -85,6 +104,31 @@ describe("projectConfig", () => {
       ).to.throw(FirebaseError, /Invalid codebase name/);
     });
 
+    it("fails validation given prefix with invalid characters", () => {
+      expect(() => projectConfig.validate([{ ...TEST_CONFIG_0, prefix: "abc.efg" }])).to.throw(
+        FirebaseError,
+        /Invalid prefix/,
+      );
+    });
+
+    it("fails validation given prefix with capital letters", () => {
+      expect(() => projectConfig.validate([{ ...TEST_CONFIG_0, prefix: "ABC" }])).to.throw(
+        FirebaseError,
+        /Invalid prefix/,
+      );
+    });
+
+    it("fails validation given a duplicate source/prefix pair", () => {
+      const config = [
+        { source: "foo", codebase: "bar", prefix: "a" },
+        { source: "foo", codebase: "baz", prefix: "a" },
+      ];
+      expect(() => projectConfig.validate(config as projectConfig.NormalizedConfig)).to.throw(
+        FirebaseError,
+        /More than one functions config specifies the same source directory/,
+      );
+    });
+
     it("should allow a single function in an array to have a default codebase", () => {
       const config = [{ source: "foo" }];
       const expected = [{ source: "foo", codebase: "default" }];

src/functions/projectConfig.ts

@@ -2,7 +2,7 @@ import { FunctionsConfig, FunctionConfig } from "../firebaseConfig";
 import { FirebaseError } from "../error";
 
 export type NormalizedConfig = [FunctionConfig, ...FunctionConfig[]];
-export type ValidatedSingle = FunctionConfig & { source: string; codebase: string };
+export type ValidatedSingle = FunctionConfig & { source:string; codebase: string };
 export type ValidatedConfig = [ValidatedSingle, ...ValidatedSingle[]];
 
 export const DEFAULT_CODEBASE = "default";
@@ -37,6 +37,20 @@ export function validateCodebase(codebase: string): void {
   }
 }
 
+/**
+ * Check that the prefix contains only allowed characters.
+ */
+export function validatePrefix(prefix: string): void {
+  if (prefix.length > 30) {
+    throw new FirebaseError("Invalid prefix. Prefix must be 30 characters or less.");
+  }
+  if (!/^[a-z0-9-]+$/.test(prefix)) {
+    throw new FirebaseError(
+      "Invalid prefix. Prefix can contain only lowercase letters, numeric characters, and dashes.",
+    );
+  }
+}
+
 function validateSingle(config: FunctionConfig): ValidatedSingle {
   if (!config.source) {
     throw new FirebaseError("codebase source must be specified");
@@ -45,6 +59,9 @@ function validateSingle(config: FunctionConfig): ValidatedSingle {
     config.codebase = DEFAULT_CODEBASE;
   }
   validateCodebase(config.codebase);
+  if (config.prefix) {
+    validatePrefix(config.prefix);
+  }
 
   return { ...config, source: config.source, codebase: config.codebase };
 }
@@ -72,21 +89,26 @@ export function assertUnique(
   }
 }
 
+function assertUniqueSourcePrefixPair(config: ValidatedConfig): void {
+  const sourcePrefixPairs = new Set<string>();
+  for (const c of config) {
+    const key = `${c.source || ""}-${c.prefix || ""}`;
+    if (sourcePrefixPairs.has(key)) {
+      throw new FirebaseError(
+        `More than one functions config specifies the same source directory ('${c.source}') and function name prefix ('${c.prefix || ""}').`,
+      );
+    }
+    sourcePrefixPairs.add(key);
+  }
+}
+
 /**
  * Validate functions config.
  */
 export function validate(config: NormalizedConfig): ValidatedConfig {
-  if (config.length > 1) {
-    for (const c of config) {
-      if (!c.codebase) {
-        throw new FirebaseError(
-          "Each functions config must have a unique 'codebase' field when defining multiple functions.",
-        );
-      }
-    }
-  }
   const validated = config.map((cfg) => validateSingle(cfg)) as ValidatedConfig;
   assertUnique(validated, "codebase");
+  assertUniqueSourcePrefixPair(validated);
   return validated;
 }
 
@@ -108,4 +130,4 @@ export function configForCodebase(config: ValidatedConfig, codebase: string): Va
     throw new FirebaseError(`No functions config found for codebase ${codebase}`);
   }
   return codebaseCfg;
-}
+}