feat: Added getCurrentUserPayments API

Author: hiranya911

firestore-stripe-web-sdk/etc/firestore-stripe-payments.api.md

@@ -44,12 +44,20 @@ export interface CreateCheckoutSessionOptions {
 // @public
 export function getCurrentUserPayment(payments: StripePayments, paymentId: string): Promise<Payment>;
 
+// @public (undocumented)
+export function getCurrentUserPayments(payments: StripePayments, options?: GetPaymentsOptions): Promise<Payment[]>;
+
 // @public
 export function getCurrentUserSubscription(payments: StripePayments, subscriptionId: string): Promise<Subscription>;
 
 // @public
 export function getCurrentUserSubscriptions(payments: StripePayments, options?: GetSubscriptionsOptions): Promise<Subscription[]>;
 
+// @public
+export interface GetPaymentsOptions {
+    status?: PaymentStatus | PaymentStatus[];
+}
+
 // @public
 export function getPrice(payments: StripePayments, productId: string, priceId: string): Promise<Price>;
 
@@ -126,15 +134,15 @@ export interface Payment {
         product: string;
         price: string;
     }>;
-    readonly status: PaymentState;
+    readonly status: PaymentStatus;
     readonly uid: string;
 }
 
 // @public
 export type PaymentMethodType = "card" | "acss_debit" | "afterpay_clearpay" | "alipay" | "bacs_debit" | "bancontact" | "boleto" | "eps" | "fpx" | "giropay" | "grabpay" | "ideal" | "klarna" | "oxxo" | "p24" | "sepa_debit" | "sofort" | "wechat_pay";
 
 // @public
-export type PaymentState = "requires_payment_method" | "requires_confirmation" | "requires_action" | "processing" | "requires_capture" | "cancelled" | "succeeded";
+export type PaymentStatus = "requires_payment_method" | "requires_confirmation" | "requires_action" | "processing" | "requires_capture" | "cancelled" | "succeeded";
 
 // @public
 export interface Price {

firestore-stripe-web-sdk/src/index.ts

@@ -38,7 +38,13 @@ export {
   SessionCreateParams,
 } from "./session";
 
-export { Payment, PaymentState, getCurrentUserPayment } from "./payment";
+export {
+  GetPaymentsOptions,
+  Payment,
+  PaymentStatus,
+  getCurrentUserPayment,
+  getCurrentUserPayments,
+} from "./payment";
 
 export {
   GetProductOptions,

firestore-stripe-web-sdk/src/payment.ts

@@ -16,19 +16,25 @@
 
 import { FirebaseApp } from "@firebase/app";
 import {
+  collection,
   doc,
   DocumentData,
   DocumentReference,
   DocumentSnapshot,
   Firestore,
   FirestoreDataConverter,
   getDoc,
+  getDocs,
   getFirestore,
+  query,
+  Query,
   QueryDocumentSnapshot,
+  QuerySnapshot,
+  where,
 } from "@firebase/firestore";
 import { StripePayments, StripePaymentsError } from "./init";
 import { getCurrentUser } from "./user";
-import { checkNonEmptyString } from "./utils";
+import { checkNonEmptyArray, checkNonEmptyString } from "./utils";
 
 /**
  * Interface of a Stripe payment stored in the app database.
@@ -103,7 +109,7 @@ export interface Payment {
   /**
    * Status of this payment.
    */
-  readonly status: PaymentState;
+  readonly status: PaymentStatus;
 
   /**
    * Firebase Auth UID of the user that created the payment.
@@ -116,7 +122,7 @@ export interface Payment {
 /**
  * Possible states a payment can be in.
  */
-export type PaymentState =
+export type PaymentStatus =
   | "requires_payment_method"
   | "requires_confirmation"
   | "requires_action"
@@ -144,6 +150,43 @@ export function getCurrentUserPayment(
   });
 }
 
+/**
+ * Optional parameters for the {@link getCurrentUserPayments} function.
+ */
+export interface GetPaymentsOptions {
+  /**
+   * Specify one or more payment status values to retrieve. When set only the payments
+   * with the given status are returned.
+   */
+  status?: PaymentStatus | PaymentStatus[];
+}
+
+export function getCurrentUserPayments(
+  payments: StripePayments,
+  options?: GetPaymentsOptions
+): Promise<Payment[]> {
+  const queryOptions: { status?: PaymentStatus[] } = {};
+  if (typeof options?.status !== "undefined") {
+    queryOptions.status = getStatusAsArray(options.status);
+  }
+
+  return getCurrentUser(payments).then((uid: string) => {
+    const dao: PaymentDAO = getOrInitPaymentDAO(payments);
+    return dao.getPayments(uid, queryOptions);
+  });
+}
+
+function getStatusAsArray(
+  status: PaymentStatus | PaymentStatus[]
+): PaymentStatus[] {
+  if (typeof status === "string") {
+    return [status];
+  }
+
+  checkNonEmptyArray(status, "status must be a non-empty array.");
+  return status;
+}
+
 /**
  * Internal interface for all database interactions pertaining to Stripe payments. Exported
  * for testing.
@@ -152,6 +195,10 @@ export function getCurrentUserPayment(
  */
 export interface PaymentDAO {
   getPayment(uid: string, paymentId: string): Promise<Payment>;
+  getPayments(
+    uid: string,
+    options?: { status?: PaymentStatus[] }
+  ): Promise<Payment[]>;
 }
 
 const PAYMENT_CONVERTER: FirestoreDataConverter<Payment> = {
@@ -209,6 +256,22 @@ class FirestorePaymentDAO implements PaymentDAO {
     return snap.data();
   }
 
+  public async getPayments(
+    uid: string,
+    options?: { status?: PaymentStatus[] }
+  ): Promise<Payment[]> {
+    const querySnap: QuerySnapshot<Payment> = await this.getPaymentSnapshots(
+      uid,
+      options?.status
+    );
+    const payments: Payment[] = [];
+    querySnap.forEach((snap: QueryDocumentSnapshot<Payment>) => {
+      payments.push(snap.data());
+    });
+
+    return payments;
+  }
+
   private async getPaymentSnapshotIfExists(
     uid: string,
     paymentId: string
@@ -233,6 +296,23 @@ class FirestorePaymentDAO implements PaymentDAO {
     return snapshot;
   }
 
+  private async getPaymentSnapshots(
+    uid: string,
+    status?: PaymentStatus[]
+  ): Promise<QuerySnapshot<Payment>> {
+    let paymentsQuery: Query<Payment> = collection(
+      this.firestore,
+      this.customersCollection,
+      uid,
+      PAYMENTS_COLLECTION
+    ).withConverter(PAYMENT_CONVERTER);
+    if (status) {
+      paymentsQuery = query(paymentsQuery, where("status", "in", status));
+    }
+
+    return await this.queryFirestore(() => getDocs(paymentsQuery));
+  }
+
   private async queryFirestore<T>(fn: () => Promise<T>): Promise<T> {
     try {
       return await fn();

firestore-stripe-web-sdk/test/emulator.spec.ts

@@ -40,6 +40,7 @@ import {
 import {
   createCheckoutSession,
   getCurrentUserPayment,
+  getCurrentUserPayments,
   getCurrentUserSubscription,
   getCurrentUserSubscriptions,
   getPrice,
@@ -61,6 +62,7 @@ import {
   economyPlan,
   payment1,
   payment2,
+  payment3,
   PaymentData,
   premiumPlan,
   premiumPlanPrice,
@@ -1005,6 +1007,68 @@ describe("Emulator tests", () => {
     });
   });
 
+  describe("getCurrentUserPayments()", () => {
+    context("without user signed in", () => {
+      it("rejects when fetching payments", async () => {
+        const err: any = await expect(
+          getCurrentUserPayments(payments)
+        ).to.be.rejectedWith(
+          "Failed to determine currently signed in user. User not signed in."
+        );
+
+        expect(err).to.be.instanceOf(StripePaymentsError);
+        expect(err.code).to.equal("unauthenticated");
+        expect(err.cause).to.be.undefined;
+      });
+    });
+
+    context("with user signed in", () => {
+      let currentUser: string = "";
+
+      before(async () => {
+        currentUser = (await signInAnonymously(auth)).user.uid;
+        await addUserData(currentUser);
+        await addPaymentData(currentUser, rawPaymentData);
+      });
+
+      after(async () => {
+        await signOut(auth);
+      });
+
+      it("should return all payments when called without options", async () => {
+        const paymentData: Payment[] = await getCurrentUserPayments(payments);
+
+        const expected: Payment[] = [
+          { ...payment1, uid: currentUser },
+          { ...payment2, uid: currentUser },
+          { ...payment3, uid: currentUser },
+        ];
+        expect(paymentData).to.eql(expected);
+      });
+
+      it("should only return payments with the given status", async () => {
+        const paymentData: Payment[] = await getCurrentUserPayments(payments, {
+          status: "succeeded",
+        });
+
+        const expected: Payment[] = [{ ...payment1, uid: currentUser }];
+        expect(paymentData).to.eql(expected);
+      });
+
+      it("should only return payments with the given statuses", async () => {
+        const paymentData: Payment[] = await getCurrentUserPayments(payments, {
+          status: ["succeeded", "requires_action"],
+        });
+
+        const expected: Payment[] = [
+          { ...payment1, uid: currentUser },
+          { ...payment2, uid: currentUser },
+        ];
+        expect(paymentData).to.eql(expected);
+      });
+    });
+  });
+
   async function addProductData(
     productId: string,
     data: ProductData