How can I avoid casting between firebase-admin and client Firestore types?

The issue you're encountering stems from the fact that the Firestore instance types exposed by the Admin SDK and the client SDK are fundamentally different. The Admin SDK's Firestore instance is designed for backend use and does not have the same shape (i.e. properties like type, app, and toJSON) as the client’s Firestore instance.

Why the Cast?

When you write

TYPESCRIPTCopied
const adminFirestore: Firestore = getFirestore() as unknown as Firestore;

you're forcibly telling TypeScript to treat the Admin SDK instance like the client SDK instance. However, this is only a type assertion and doesn't change the underlying object. This means that even though your code compiles, you might run into runtime issues if the two APIs don't behave the same way or the methods/properties you expect from the client Firestore instance aren't available.

Recommendations

1. Separate Abstractions:
   Instead of trying to reuse client-side Firestore code directly with the Admin SDK, consider abstracting your Firestore logic behind an interface. Then create two implementations, one for the client and one for the Admin SDK. This abstracts the differences between the two environments and keeps your code clear about which API it is using.

2. Adapter/Wrapper Pattern:
   If you must reuse the same code, you could write an adapter that wraps the Admin Firestore instance and exposes the portions of the client SDK’s interface you need. This adapter could simulate the properties expected by your client code (like type, app, or toJSON), but keep in mind that they may just be dummy values or wrappers around their Admin SDK functionality.

Example Interface Abstraction

TYPESCRIPTCopied
// Define an interface that abstracts the Firestore methods you need:
export interface MyFirestore {
  getDocument(ref: string): Promise<any>;
  // ...other common methods
}

// Client implementation (using the client SDK)
export class ClientFirestore implements MyFirestore {
  constructor(private db: Firestore) {}

  getDocument(ref: string): Promise<any> {
    // Use client Firestore methods
    return this.db.doc(ref).get();
  }
}

// Admin implementation (using the Admin SDK)
export class AdminFirestore implements MyFirestore {
  constructor(private db: import('firebase-admin/firestore').Firestore) {}

  getDocument(ref: string): Promise<any> {
    // Use Admin Firestore methods
    return this.db.doc(ref).get();
  }
}

Using this abstraction, your common code only relies on the MyFirestore interface and not the specific details of the client or Admin Firestore types.

Conclusion

There is no built-in way to avoid this cast because the firestore instances from each SDK are inherently different. The recommended approach is to separate your business logic from the underlying Firestore instance types. This ensures that your code works correctly in both client and server contexts without unsafe type assertions.