@firebase-function-kits/delete-user-data 0.0.2-rc.3 → 0.0.2-rc.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firebase-function-kits/delete-user-data",
-  "version": "0.0.2-rc.3",
+  "version": "0.0.2-rc.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/firebase/extensions.git",
@@ -34,13 +34,6 @@
     "@google-cloud/pubsub": "^4.3.3",
     "firebase-admin": "^13.2.0",
     "firebase-functions": "^7.3.2",
-    "lodash.chunk": "^4.2.0",
-    "node-fetch": "^2.6.2"
-  },
-  "devDependencies": {
-    "@types/lodash.chunk": "^4.2.7",
-    "@types/node-fetch": "^2.6.2",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.10"
+    "lodash.chunk": "^4.2.0"
   }
 }

package/src/config.ts

@@ -18,17 +18,20 @@ import {
   defineBoolean,
   defineInt,
   defineString,
-  expr,
+  type IntParam,
   projectID,
   select,
   storageBucket,
 } from "firebase-functions/params";
 import type { DeleteUserDataConfig } from "./export-config";
 
-const instanceId = defineString("INSTANCE_ID");
+// firebase-tools injects this for kit instances (set to the instance's key in
+// firebase.json) during discovery, in the emulator, and on deployed functions.
+// The FIREBASE_ prefix is reserved in .env files and the params machinery never
+// sees injected values, so it must be a plain env read, not a defineString.
+const instanceId = process.env.FIREBASE_KIT_INSTANCE_ID;
 
 const params = {
-  instanceId,
   firestorePaths: defineString("FIRESTORE_PATHS", {
     label: "Cloud Firestore paths",
     description:
@@ -148,10 +151,10 @@ const params = {
   // Non-empty defaults so Pub/Sub trigger bindings resolve during deploy
   // discovery without freezing an empty topic name into the manifest.
   discoveryTopicName: defineString("DISCOVERY_TOPIC_NAME", {
-    default: expr`kit-${instanceId}-discovery`,
+    default: `kit-${instanceId}-discovery`,
   }),
   deletionTopicName: defineString("DELETION_TOPIC_NAME", {
-    default: expr`kit-${instanceId}-deletion`,
+    default: `kit-${instanceId}-deletion`,
   }),
 };
 
@@ -164,7 +167,25 @@ function optional(value: string): string | undefined {
   return value.length > 0 ? value : undefined;
 }
 
+// defineInt resolves a missing or blank env var to 0, so a declared default
+// never reaches runtime. Report those as unset and let the resolver apply the
+// documented default. An explicit 0 is a real setting and is preserved.
+function optionalInt(param: IntParam): number | undefined {
+  // Quoted values keep their whitespace through the CLI's .env parser, and a
+  // whitespace-only value would otherwise parse to 0.
+  const raw = process.env[param.name]?.trim();
+  return raw === undefined || raw === "" ? undefined : param.value();
+}
+
 export function configFromEnv(): DeleteUserDataConfig {
+  const instanceId = process.env.FIREBASE_KIT_INSTANCE_ID;
+  if (!instanceId) {
+    throw new Error(
+      "FIREBASE_KIT_INSTANCE_ID is not set. It is provided automatically to " +
+        "kit instances by firebase-tools >= 15.27.0; deploy or emulate this " +
+        "kit with a supported CLI version."
+    );
+  }
   return {
     firestorePaths: optional(params.firestorePaths.value()),
     firestoreDatabaseId: params.firestoreDatabaseId.value(),
@@ -177,10 +198,10 @@ export function configFromEnv(): DeleteUserDataConfig {
       optional(params.storageBucket.value()) ?? process.env.STORAGE_BUCKET,
     storagePaths: optional(params.storagePaths.value()),
     enableAutoDiscovery: params.enableAutoDiscovery.value(),
-    searchDepth: params.searchDepth.value(),
+    searchDepth: optionalInt(params.searchDepth),
     searchFields: params.searchFields.value(),
     searchFunction: optional(params.searchFunction.value()),
-    instanceId: params.instanceId.value(),
+    instanceId,
     discoveryTopicName: optional(params.discoveryTopicName.value()),
     deletionTopicName: optional(params.deletionTopicName.value()),
     projectId: projectID.value(),

package/src/runCustomSearchFunction.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import fetch from "node-fetch";
 import * as logs from "./logs";
 import type { PublisherContext } from "./runBatchPubSubDeletions";
 import { runBatchPubSubDeletions } from "./runBatchPubSubDeletions";

package/tests/config-runtime.test.ts

@@ -0,0 +1,69 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { configFromEnv } from "../src/config";
+import { resolveDeleteUserDataConfig } from "../src/export-config";
+
+// config.test.ts fakes firebase-functions/params, so it cannot see how the real
+// IntParam resolves a missing env var. These cases run against the real one.
+function resolvedSearchDepth(raw?: string): number {
+  if (raw === undefined) {
+    delete process.env.AUTO_DISCOVERY_SEARCH_DEPTH;
+  } else {
+    process.env.AUTO_DISCOVERY_SEARCH_DEPTH = raw;
+  }
+  return resolveDeleteUserDataConfig(configFromEnv()).searchDepth;
+}
+
+describe("searchDepth from the runtime environment", () => {
+  const original = process.env.AUTO_DISCOVERY_SEARCH_DEPTH;
+
+  beforeEach(() => {
+    vi.stubEnv("FIREBASE_KIT_INSTANCE_ID", "test-instance");
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    if (original === undefined) {
+      delete process.env.AUTO_DISCOVERY_SEARCH_DEPTH;
+    } else {
+      process.env.AUTO_DISCOVERY_SEARCH_DEPTH = original;
+    }
+  });
+
+  test("falls back to the documented default when unset", () => {
+    expect(resolvedSearchDepth(undefined)).toBe(3);
+  });
+
+  // An extension .env that left the value empty resolved to 3, not 0.
+  test("falls back to the documented default when blank", () => {
+    expect(resolvedSearchDepth("")).toBe(3);
+  });
+
+  // A quoted "   " survives the CLI's .env parser untrimmed.
+  test("falls back to the documented default when whitespace only", () => {
+    expect(resolvedSearchDepth("   ")).toBe(3);
+  });
+
+  test("preserves an explicit zero", () => {
+    expect(resolvedSearchDepth("0")).toBe(0);
+  });
+
+  test("preserves an explicit depth", () => {
+    expect(resolvedSearchDepth("5")).toBe(5);
+  });
+});

package/tests/config.test.ts

@@ -48,7 +48,9 @@ const defineString = vi.fn(
     new FakeStringParam(name, opts?.default)
 );
 
-const defineInt = vi.fn((_name: string, opts?: { default?: number }) => ({
+// Carries name so configFromEnv can look the variable up, as the real one does.
+const defineInt = vi.fn((name: string, opts?: { default?: number }) => ({
+  name,
   value: () => opts?.default ?? 0,
 }));
 
@@ -56,17 +58,6 @@ const defineBoolean = vi.fn((_name: string, opts?: { default?: boolean }) => ({
   value: () => opts?.default ?? false,
 }));
 
-const expr = vi.fn(
-  (strings: TemplateStringsArray, ...values: unknown[]) =>
-    new FakeExpression(
-      strings.reduce(
-        (result, part, index) =>
-          result + part + (index < values.length ? cel(values[index]) : ""),
-        ""
-      )
-    )
-);
-
 function cel(value: unknown): string {
   return value instanceof FakeExpression ? value.toCEL() : String(value);
 }
@@ -76,7 +67,6 @@ vi.mock("firebase-functions/params", () => ({
   defineBoolean,
   defineInt,
   defineString,
-  expr,
   projectID: { value: () => "demo-test" },
   select: vi.fn((options: string[]) => ({ options })),
   storageBucket: new FakeStringParam("STORAGE_BUCKET", "demo-test.appspot.com"),
@@ -87,7 +77,7 @@ async function importConfig() {
   defineString.mockClear();
   defineInt.mockClear();
   defineBoolean.mockClear();
-  expr.mockClear();
+  vi.stubEnv("FIREBASE_KIT_INSTANCE_ID", "test-instance");
 
   return import("../src/config");
 }
@@ -105,7 +95,6 @@ describe("configFromEnv", () => {
       firestoreDeleteMode: "shallow",
       rtdbLocation: "us-central1",
       enableAutoDiscovery: false,
-      searchDepth: 3,
       searchFields: "id,uid,userId",
       projectId: "demo-test",
     });
@@ -120,6 +109,7 @@ describe("configFromEnv", () => {
     expect(config.storagePaths).toBeUndefined();
     expect(config.searchFunction).toBeUndefined();
     expect(config.rtdbInstance).toBeUndefined();
+    expect(config.searchDepth).toBeUndefined();
   });
 
   test("declares the params the extension exposes", async () => {
@@ -128,7 +118,6 @@ describe("configFromEnv", () => {
     const declared = defineString.mock.calls.map(([name]) => name);
     expect(declared).toEqual(
       expect.arrayContaining([
-        "INSTANCE_ID",
         "FIRESTORE_PATHS",
         "FIRESTORE_DATABASE_ID",
         "FIRESTORE_DELETE_MODE",
@@ -153,7 +142,33 @@ describe("configFromEnv", () => {
     ]);
   });
 
-  test("defaults the topic names to kit-{instanceId}-* expressions", async () => {
+  // The CLI injects FIREBASE_KIT_INSTANCE_ID as a reserved env var; declaring
+  // it (or INSTANCE_ID) as a param makes the CLI prompt for a value it cannot
+  // accept and abort loading the kit.
+  test("does not declare an instance-id param", async () => {
+    await importConfig();
+
+    const declared = defineString.mock.calls.map(([name]) => name);
+    expect(declared).not.toContain("INSTANCE_ID");
+    expect(declared).not.toContain("FIREBASE_KIT_INSTANCE_ID");
+  });
+
+  test("reads the instance id from the injected environment", async () => {
+    const { configFromEnv } = await importConfig();
+
+    expect(configFromEnv().instanceId).toBe("test-instance");
+  });
+
+  test("throws when FIREBASE_KIT_INSTANCE_ID is missing", async () => {
+    const { configFromEnv } = await importConfig();
+    vi.stubEnv("FIREBASE_KIT_INSTANCE_ID", undefined);
+
+    expect(() => configFromEnv()).toThrow(
+      /FIREBASE_KIT_INSTANCE_ID is not set/
+    );
+  });
+
+  test("defaults the topic names to kit-{instanceId}-*", async () => {
     const { CONFIG_EXPRESSIONS } = await importConfig();
 
     expect(cel(CONFIG_EXPRESSIONS.discoveryTopicName)).toBe(
@@ -162,13 +177,13 @@ describe("configFromEnv", () => {
     expect(cel(CONFIG_EXPRESSIONS.deletionTopicName)).toBe(
       "{{ params.DELETION_TOPIC_NAME }}"
     );
-    expect(expr.mock.results.map((result) => cel(result.value))).toEqual([
-      "kit-{{ params.INSTANCE_ID }}-discovery",
-      "kit-{{ params.INSTANCE_ID }}-deletion",
-    ]);
     expect(defineString.mock.calls).toContainEqual([
       "DISCOVERY_TOPIC_NAME",
-      { default: expect.anything() },
+      { default: "kit-test-instance-discovery" },
+    ]);
+    expect(defineString.mock.calls).toContainEqual([
+      "DELETION_TOPIC_NAME",
+      { default: "kit-test-instance-deletion" },
     ]);
   });
 

package/tests/context.test.ts

@@ -14,20 +14,29 @@
  * limitations under the License.
  */
 
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 
 // Stands in for a project with no Realtime Database URL available, which is what
 // an empty SELECTED_DATABASE_INSTANCE leaves behind.
 const NO_DATABASE_URL = "Can't determine Firebase Database URL.";
 
+const FIRESTORE_DATABASE_ID = "user-data";
+const PROJECT_ID = "test-project";
+
 vi.mock("../src/logs");
 vi.mock("../src/handlers", async (importOriginal) => ({
   ...(await importOriginal<typeof import("../src/handlers")>()),
   handleClear: vi.fn(),
 }));
-vi.mock("@google-cloud/pubsub", () => ({ PubSub: vi.fn() }));
+// The clients carry their construction arguments, which survive the beforeEach
+// that clears the call history recorded when the context was memoized.
+vi.mock("@google-cloud/pubsub", () => ({
+  PubSub: class {
+    constructor(public readonly options?: { projectId?: string }) {}
+  },
+}));
 vi.mock("firebase-admin/firestore", () => ({
-  getFirestore: vi.fn(() => ({})),
+  getFirestore: vi.fn((databaseId?: string) => ({ databaseId })),
 }));
 vi.mock("firebase-admin", () => ({
   apps: [],
@@ -55,9 +64,29 @@ function deletionEvent(uid: string) {
   } as any;
 }
 
+function contextFrom(uid: string): HandlerContext {
+  clearData(deletionEvent(uid));
+
+  const [, ctx] = vi.mocked(handleClear).mock.lastCall as [
+    string,
+    HandlerContext
+  ];
+  return ctx;
+}
+
 describe("handler context", () => {
+  // Stubbed per test: the afterEach unstubAllEnvs would wipe beforeAll stubs
+  // after the first test.
   beforeEach(() => {
     vi.clearAllMocks();
+    vi.stubEnv("FIREBASE_KIT_INSTANCE_ID", "test-instance");
+    vi.stubEnv("FIRESTORE_DATABASE_ID", FIRESTORE_DATABASE_ID);
+    // The projectID param reads the project from FIREBASE_CONFIG.
+    vi.stubEnv("FIREBASE_CONFIG", JSON.stringify({ projectId: PROJECT_ID }));
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
   });
 
   test("builds without resolving the RTDB client", () => {
@@ -68,14 +97,25 @@ describe("handler context", () => {
   });
 
   test("resolves the RTDB client when the deletion path reads it", () => {
-    clearData(deletionEvent("uid-2"));
-
-    const [, ctx] = vi.mocked(handleClear).mock.lastCall as [
-      string,
-      HandlerContext
-    ];
+    const ctx = contextFrom("uid-2");
 
     expect(() => ctx.database).toThrow(NO_DATABASE_URL);
     expect(admin.database).toHaveBeenCalled();
   });
+
+  test("reuses one context across invocations", () => {
+    expect(contextFrom("uid-3")).toBe(contextFrom("uid-4"));
+  });
+
+  test("builds the Firestore client for the configured database", () => {
+    expect(contextFrom("uid-5").firestore).toEqual({
+      databaseId: FIRESTORE_DATABASE_ID,
+    });
+  });
+
+  test("builds the Pub/Sub client for the configured project", () => {
+    expect(contextFrom("uid-6").pubsub).toEqual({
+      options: { projectId: PROJECT_ID },
+    });
+  });
 });

package/tests/handlers.test.ts

@@ -20,7 +20,7 @@ const mocks = vi.hoisted(() => ({ fetch: vi.fn() }));
 
 vi.mock("../src/logs");
 vi.mock("../src/events");
-vi.mock("node-fetch", () => ({ default: mocks.fetch }));
+vi.stubGlobal("fetch", mocks.fetch);
 
 import * as events from "../src/events";
 import { handleClear, handleDeletion, handleSearch } from "../src/handlers";

package/tests/runCustomSearchFunction.test.ts

@@ -20,7 +20,7 @@ const mocks = vi.hoisted(() => ({ fetch: vi.fn() }));
 
 vi.mock("../src/logs");
 vi.mock("../src/events");
-vi.mock("node-fetch", () => ({ default: mocks.fetch }));
+vi.stubGlobal("fetch", mocks.fetch);
 
 import * as logs from "../src/logs";
 import { runCustomSearchFunction } from "../src/runCustomSearchFunction";