fix(emulator): keep firebase-admin statics when proxying; don't crash logging circular thrown values

CHANGELOG.md

@@ -1,3 +1,4 @@
+- Fixed the Functions emulator dropping static properties (such as `admin.firestore.Timestamp`) of `firebase-admin` namespaces, and a crash while logging thrown values that contain circular references.
 - Improved Auth emulator startup time by compiling validation schemas lazily. (#11176)
 - Updated the Firebase SQL Connect local toolkit to v3.4.26, which includes the following changes:
   - Internal improvements and bug fixes.

src/emulator/functionsEmulatorRuntime.spec.ts

@@ -0,0 +1,38 @@
+import { expect } from "chai";
+
+import { Proxied } from "./functionsEmulatorRuntime";
+
+describe("Proxied.getOriginal", () => {
+  it("keeps own static properties of bound functions", () => {
+    // Mirrors firebase-admin 13, where `admin.firestore` is an arrow function
+    // (no prototype) with members attached to it.
+    const firestore: any = () => "instance";
+    firestore.Timestamp = class Timestamp {};
+    firestore.FieldValue = { serverTimestamp: () => "ts" };
+    Object.defineProperty(firestore, "lazy", { get: () => 42, enumerable: true });
+
+    const bound = Proxied.getOriginal({ firestore }, "firestore");
+
+    expect(bound()).to.equal("instance");
+    expect(bound.Timestamp).to.equal(firestore.Timestamp);
+    expect(bound.FieldValue.serverTimestamp()).to.equal("ts");
+    expect(bound.lazy).to.equal(42);
+  });
+
+  it("still binds methods to the target", () => {
+    const target = {
+      value: 7,
+      get() {
+        return this.value;
+      },
+    };
+    expect(Proxied.getOriginal(target, "get")()).to.equal(7);
+  });
+
+  it("returns constructors and non-functions untouched", () => {
+    class Foo {}
+    expect(Proxied.getOriginal({ Foo }, "Foo")).to.equal(Foo);
+    expect(Proxied.getOriginal({ a: 1 }, "a")).to.equal(1);
+    expect(Proxied.getOriginal({}, "missing")).to.equal(undefined);
+  });
+});

src/emulator/functionsEmulatorRuntime.ts

@@ -95,7 +95,7 @@ interface ProxyTarget extends Object {
   obj.value === 1;
   obj.incremented === 2;
    */
-class Proxied<T extends ProxyTarget> {
+export class Proxied<T extends ProxyTarget> {
   /**
    * Gets a property from the original object.
    */
@@ -107,10 +107,30 @@ class Proxied<T extends ProxyTarget> {
     } else if (Proxied.isConstructor(value) || typeof value !== "function") {
       return value;
     } else {
-      return value.bind(target);
+      return Proxied.bindKeepingStatics(value, target);
     }
   }
 
+  /**
+   * Binds a function to a target while preserving the function's own static
+   * properties. Function.prototype.bind drops them, which breaks namespaces
+   * that are functions with attached members (e.g. firebase-admin's
+   * `admin.firestore.Timestamp`).
+   */
+  private static bindKeepingStatics(fn: (...args: any[]) => any, target: any): any {
+    const bound = fn.bind(target);
+    for (const key of Reflect.ownKeys(fn)) {
+      if (key === "length" || key === "name" || key === "prototype") {
+        continue;
+      }
+      const desc = Object.getOwnPropertyDescriptor(fn, key);
+      if (desc) {
+        Object.defineProperty(bound, key, desc);
+      }
+    }
+    return bound;
+  }
+
   /**
    * Run the original target.
    */

src/error.spec.ts

@@ -1,5 +1,5 @@
 import { expect } from "chai";
-import { FirebaseError } from "./error";
+import { FirebaseError, getErrMsg, getErrStack } from "./error";
 
 describe("error", () => {
   describe("FirebaseError", () => {
@@ -38,4 +38,14 @@ describe("error", () => {
       expect(error).to.deep.include(allOptions);
     });
   });
+
+  describe("getErrMsg", () => {
+    it("does not throw on a circular non-Error value", () => {
+      const circular: Record<string, unknown> = { msg: "real message" };
+      circular.self = circular;
+
+      expect(getErrMsg(circular)).to.contain("real message");
+      expect(getErrStack(circular)).to.contain("real message");
+    });
+  });
 });

src/error.ts

@@ -1,3 +1,4 @@
+import { inspect } from "util";
 import { defaultTo } from "lodash";
 
 interface FirebaseErrorOptions {
@@ -47,7 +48,12 @@ export function getErrMsg(err: unknown, defaultMsg?: string): string {
   } else if (defaultMsg) {
     return defaultMsg;
   }
-  return JSON.stringify(err);
+  try {
+    return JSON.stringify(err);
+  } catch {
+    // e.g. a circular structure; fall back to something that cannot throw.
+    return inspect(err);
+  }
 }
 
 /**