@bash-app/bash-common 30.59.4 → 30.59.6

package/src/membershipDefinitions.ts

@@ -1,7 +1,61 @@
 // Membership tier definitions and constants shared between frontend and backend
-import { MembershipBillingInterval, MembershipTier, MembershipTierInfo } from './extendedSchemas';
+import { MembershipTier } from '@prisma/client';
 
-export { MembershipBillingInterval, MembershipTier };
+export { MembershipTier };
+
+export type MembershipBillingInterval = 'Monthly' | 'Yearly';
+
+export interface MembershipTierInfo {
+  tier: MembershipTier;
+  name: string;
+  monthlyPrice: number;
+  yearlyPrice: number;
+  features: string[];
+  limits: {
+    bashEventsPerMonth?: number;
+    featuredEventsPerMonth?: number;
+    analyticsAccess: boolean;
+    vendorDirectoryAccess: boolean;
+    prioritySupport: boolean;
+  };
+}
+
+// API-related interfaces
+export interface UserMembershipStatus {
+  currentTier: MembershipTier;
+  expiresAt?: string;
+  autoRenew: boolean;
+  billingInterval?: MembershipBillingInterval;
+  featuredEventsUsed: number;
+  stripeSubscriptionId?: string;
+  canUpgrade: boolean;
+  canDowngrade: boolean;
+  features: string[];
+  subscriptionStatus: string;
+  nextBilling?: Date | null;
+  isActive: boolean;
+  currentPeriodStart?: number;
+  currentPeriodEnd?: number;
+  cancelAtPeriodEnd?: boolean;
+}
+
+export interface CreateMembershipSubscriptionArgs {
+  tierName: string;
+  interval?: "monthly" | "yearly";
+  paymentMethodId?: string;
+  userId?: string; // For API usage
+}
+
+export interface MembershipSubscriptionResult {
+  subscriptionId: string;
+  tier: MembershipTier;
+  interval: "monthly" | "yearly";
+  status: string;
+  currentPeriodStart: number;
+  currentPeriodEnd: number;
+  cancelAtPeriodEnd?: boolean;
+  clientSecret?: string;
+}
 
 // Pricing in cents (for Stripe)
 export const MEMBERSHIP_PRICING = {

package/src/utils/urlUtils.ts

@@ -1,5 +1,6 @@
 import { isProduction } from "./apiUtils";
-import { BASH_DETAIL_URL } from "../definitions";
+import { BASH_DETAIL_URL, STRIPE_CHECKOUT_TIMEOUT_MS, STRIPE_REDIRECT_TIMEOUT_MS } from "../definitions";
+import { generateBashDetailUrl } from "./slugUtils";
 
 const API_HOST = process.env.REACT_APP_API ?? "http://localhost:3500";
 
@@ -86,3 +87,115 @@ export function urlRemoveQueryParam(url: string, keys: string[]): string {
 
   return newUrl;
 }
+
+/**
+ * Constructs a full Stripe checkout URL by combining bash event detail URL with checkout path
+ * Used by backend to create success/cancel URLs for Stripe checkout sessions
+ * 
+ * @param bashEventId - The bash event ID
+ * @param slug - The bash event slug
+ * @param checkoutPath - Base checkout path (e.g., CHECKOUT_RETURN_SUCCESS_URL)
+ * @param baseUrl - Frontend base URL (e.g., "https://yourdomain.com")
+ * @returns Full URL for Stripe checkout session
+ * 
+ * @example
+ * buildStripeCheckoutUrl("123", "my-event", "/checkout-success/{CHECKOUT_SESSION_ID}", "https://bash.com")
+ * // Returns: "https://bash.com/bash/123-my-event/checkout-success/{CHECKOUT_SESSION_ID}"
+ */
+export function buildStripeCheckoutUrl(
+  bashEventId: string,
+  slug: string,
+  checkoutPath: string,
+  baseUrl: string
+): string {
+  // Use the existing generateBashDetailUrl function
+  const bashDetailPath = generateBashDetailUrl(bashEventId, slug);
+  return `${baseUrl}${bashDetailPath}${checkoutPath}`;
+}
+
+/**
+ * Executes a function with a timeout and retry mechanism
+ * Used for Stripe checkout operations that might be slow
+ * 
+ * @param operation - The async operation to execute
+ * @param timeoutMs - Timeout in milliseconds
+ * @param onTimeout - Callback when timeout occurs
+ * @param maxRetries - Maximum number of retries (default: 1)
+ * @returns Promise that resolves/rejects based on operation success
+ */
+export async function executeWithTimeout<T>(
+  operation: () => Promise<T>,
+  timeoutMs: number = STRIPE_CHECKOUT_TIMEOUT_MS,
+  onTimeout?: (retryCount: number) => void | Promise<void>,
+  maxRetries: number = 1
+): Promise<T> {
+  let lastError: Error | undefined;
+  
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`Operation timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      });
+
+      const operationPromise = operation();
+      
+      return await Promise.race([operationPromise, timeoutPromise]);
+    } catch (error) {
+      lastError = error as Error;
+      
+      if (attempt < maxRetries) {
+        console.warn(`Attempt ${attempt + 1} failed, retrying...`, error);
+        if (onTimeout) {
+          await onTimeout(attempt);
+        }
+      }
+    }
+  }
+  
+  throw lastError || new Error('Operation failed after all retries');
+}
+
+/**
+ * Redirects to Stripe checkout with timeout and fallback
+ * 
+ * @param redirectUrl - The Stripe checkout URL
+ * @param timeoutMs - Timeout for redirect
+ * @param onTimeout - Callback when redirect times out
+ */
+export function redirectToStripeWithTimeout(
+  redirectUrl: string,
+  timeoutMs: number = STRIPE_REDIRECT_TIMEOUT_MS,
+  onTimeout?: () => void
+): void {
+  let redirectCompleted = false;
+  
+  // Set up timeout
+  const timeoutId = setTimeout(() => {
+    if (!redirectCompleted) {
+      console.warn('Stripe redirect timed out, forcing refresh...');
+      if (onTimeout) {
+        onTimeout();
+      } else {
+        // Default behavior: refresh the page
+        window.location.reload();
+      }
+    }
+  }, timeoutMs);
+
+  try {
+    // Attempt redirect
+    window.location.href = redirectUrl;
+    redirectCompleted = true;
+    clearTimeout(timeoutId);
+  } catch (error) {
+    console.error('Failed to redirect to Stripe:', error);
+    clearTimeout(timeoutId);
+    if (onTimeout) {
+      onTimeout();
+    } else {
+      window.location.reload();
+    }
+  }
+}