Stripe Configuration

import { DBTable } from "@/types";
import { Dictionary } from "lodash";

export interface PaginationOptions {
  limit?: number;
  startingAfter?: string;
  endingBefore?: string;
}

export interface PaginatedResponse<T> {
  data: T[];
  hasMore: boolean;
  totalCount?: number;
}

export type CustomerData = {
  id?: string;
  email: string;
  metadata?: { [key: string]: any };
};

export type SubscriptionData = DBTable<"billing_subscriptions"> & {
  billing_prices: DBTable<"billing_prices"> | null;
  billing_products: DBTable<"billing_products"> | null;
};

export type ProductData = DBTable<"billing_products"> & {
  billing_prices: DBTable<"billing_prices">[];
};

export type ProductAndPrice = {
  product: DBTable<"billing_products">;
  price: DBTable<"billing_prices">;
};

export type InvoiceData = DBTable<"billing_invoices"> & {
  billing_products: DBTable<"billing_products"> | null;
  billing_prices: DBTable<"billing_prices"> | null;
};

export type OneTimePaymentData = DBTable<"billing_one_time_payments"> & {
  billing_products: DBTable<"billing_products"> | null;
  billing_prices: DBTable<"billing_prices"> | null;
  billing_invoices: DBTable<"billing_invoices"> | null;
};

export interface CheckoutSessionData {
  id: string;
  url: string;
}

export interface CustomerPortalData {
  url: string;
}

export interface PaymentMethodData {
  id: string;
  customerId: string;
  type: "card" | "bank_account" | "other";
  last4: string;
  expiryMonth?: number;
  expiryYear?: number;
}

export type CheckoutSessionOptions = {
  freeTrialDays?: number;
};

export abstract class PaymentGateway {
  abstract getName(): string;

  /**
   * These are methods which perform operations on the database.
   */
  abstract db: {
    createCustomer(
      customerData: Partial<DBTable<"billing_customers">>,
      workspaceId: string,
    ): Promise<DBTable<"billing_customers">>;
    getCustomerByCustomerId(
      customerId: string,
    ): Promise<DBTable<"billing_customers">>;
    getCustomerByWorkspaceId(
      workspaceId: string,
    ): Promise<DBTable<"billing_customers"> | null>;
    hasCustomer(customerId: string): Promise<boolean>;
    updateCustomer(
      customerId: string,
      updateData: Partial<DBTable<"billing_customers">>,
    ): Promise<DBTable<"billing_customers">>;
    deleteCustomer(customerId: string): Promise<void>;
    listCustomers(
      options?: PaginationOptions,
    ): Promise<PaginatedResponse<DBTable<"billing_customers">>>;
    // Subscription methods
    getSubscriptionsByCustomerId(
      customerId: string,
    ): Promise<SubscriptionData[]>;
    getSubscriptionsByWorkspaceId(
      workspaceId: string,
    ): Promise<SubscriptionData[]>;
    getSubscription(subscriptionId: string): Promise<SubscriptionData>;
    listSubscriptions(
      customerId: string,
      options?: PaginationOptions,
    ): Promise<PaginatedResponse<SubscriptionData>>;
    // Invoice methods
    getInvoice(invoiceId: string): Promise<InvoiceData>;
    listInvoicesByCustomerId(
      customerId: string,
      options?: PaginationOptions,
    ): Promise<PaginatedResponse<InvoiceData>>;
    listInvoicesByWorkspaceId(
      workspaceId: string,
      options?: PaginationOptions,
    ): Promise<PaginatedResponse<InvoiceData>>;
    // Product methods
    getProduct(productId: string): Promise<ProductData>;
    listProducts(options?: PaginationOptions): Promise<Array<ProductData>>;
  };

  abstract util: {
    createCustomerForWorkspace(
      workspaceId: string,
    ): Promise<DBTable<"billing_customers">>;
    getCustomerByWorkspaceId(
      workspaceId: string,
    ): Promise<DBTable<"billing_customers"> | null>;
    supportsFeature(featureName: string): boolean;
    isTestMode(): boolean;
  };

  /**
   * These are methods which perform operations on the payment gateway.
   */
  abstract gateway: {
    createGatewayCustomer(
      userData: Partial<CustomerData>,
    ): Promise<CustomerData>;
    // Webhook methods
    handleGatewayWebhook(body: any, signature: string): Promise<void>;
  };
  abstract anonScope: {
    listAllProducts(): Promise<ProductAndPrice[]>;
    /**
     * List all subscription products that are visible to the user.
     */
    listAllSubscriptionProducts(): Promise<Dictionary<ProductAndPrice[]>>;
    /**
     * List all one-time products that are visible to the user.
     */
    listAllOneTimeProducts(): Promise<ProductAndPrice[]>;
  };
  abstract userScope: {
    getWorkspaceDatabaseSubscriptions(
      workspaceId: string,
    ): Promise<DBTable<"billing_subscriptions">[]>;
    getWorkspaceDatabaseOneTimePurchases(
      workspaceId: string,
    ): Promise<OneTimePaymentData[]>;
    getWorkspaceDatabaseInvoices(
      workspaceId: string,
    ): Promise<PaginatedResponse<InvoiceData>>;
    getWorkspaceDatabasePaymentMethods(
      workspaceId: string,
    ): Promise<DBTable<"billing_payment_methods">[]>;
    getWorkspaceDatabaseCustomer(
      workspaceId: string,
    ): Promise<DBTable<"billing_customers">>;
    // Checkout methods
    createGatewayCheckoutSession({
      productId,
      priceId,
      options,
      workspaceId,
    }: {
      workspaceId: string;
      productId: string;
      priceId: string;
      options?: CheckoutSessionOptions;
    }): Promise<CheckoutSessionData>;
    // Customer portal methods
    createGatewayCustomerPortalSession(
      workspaceId: string,
      returnUrl: string,
    ): Promise<CustomerPortalData>;
  };
  abstract superAdminScope: {
    syncProducts(): Promise<void>;
    syncCustomers(): Promise<void>;
    toggleProductVisibility(
      productId: string,
      isVisible: boolean,
    ): Promise<void>;
    listAllProducts(): Promise<ProductData[]>;
    getCurrentMRR(): Promise<number>;
    getSubscriptionsByMonthBetween(
      startDate: Date,
      endDate: Date,
    ): Promise<{ month: Date; subscriptions: number }[]>;
    getCurrentRevenueByProduct(): Promise<
      { productId: string; revenue: number }[]
    >;
    getCurrentMonthRevenue(): Promise<number>;
    getLastMonthRevenue(): Promise<number>;
    listCurrentMonthInvoices(): Promise<InvoiceData[]>;
    listCurrentMonthSubscriptions(): Promise<SubscriptionData[]>;
    listCustomers(): Promise<DBTable<"billing_customers">[]>;
  };
}