[server] Refactor StripeService.createCustomer to only use attributionIds

Author: jankeromnes

components/dashboard/src/components/UsageBasedBillingConfig.tsx

@@ -296,7 +296,7 @@ function CreditCardInputForm(props: { attributionId: string }) {
         setIsLoading(true);
         try {
             // Create Stripe customer with currency
-            await getGitpodService().server.createStripeCustomer(props.attributionId, currency);
+            await getGitpodService().server.createStripeCustomerIfNeeded(props.attributionId, currency);
             const result = await stripe.confirmSetup({
                 elements,
                 confirmParams: {

components/gitpod-protocol/src/gitpod-service.ts

@@ -287,7 +287,7 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
     getStripePublishableKey(): Promise<string>;
     getStripeSetupIntentClientSecret(): Promise<string>;
     findStripeSubscriptionId(attributionId: string): Promise<string | undefined>;
-    createStripeCustomer(attributionId: string, currency: string): Promise<void>;
+    createStripeCustomerIfNeeded(attributionId: string, currency: string): Promise<void>;
     subscribeToStripe(attributionId: string, setupIntentId: string): Promise<void>;
     getStripePortalUrl(attributionId: string): Promise<string>;
     getUsageLimit(attributionId: string): Promise<number | undefined>;

components/server/ee/src/user/stripe-service.ts

@@ -43,55 +43,32 @@ export class StripeService {
         return result.data[0]?.id;
     }
 
-    async createCustomerForUser(user: User): Promise<string> {
-        const attributionId = AttributionId.render({ kind: "user", userId: user.id });
+    async createCustomerForAttributionId(
+        attributionId: string,
+        preferredCurrency: string,
+        billingEmail?: string,
+        billingName?: string,
+    ): Promise<string> {
         if (await this.findCustomerByAttributionId(attributionId)) {
-            throw new Error(`A Stripe customer already exists for user '${user.id}'`);
+            throw new Error(`A Stripe customer already exists for '${attributionId}'`);
         }
         // Create the customer in Stripe
         const customer = await this.getStripe().customers.create({
-            email: User.getPrimaryEmail(user),
-            name: User.getName(user),
-            metadata: { attributionId },
+            email: billingEmail,
+            name: billingName,
+            metadata: { attributionId, preferredCurrency },
         });
         // Wait for the customer to show up in Stripe search results before proceeding
         let attempts = 0;
         while (!(await this.findCustomerByAttributionId(attributionId))) {
             await new Promise((resolve) => setTimeout(resolve, POLL_CREATED_CUSTOMER_INTERVAL_MS));
             if (++attempts > POLL_CREATED_CUSTOMER_MAX_ATTEMPTS) {
-                throw new Error(`Could not confirm Stripe customer creation for user '${user.id}'`);
+                throw new Error(`Could not confirm Stripe customer creation for '${attributionId}'`);
             }
         }
         return customer.id;
     }
 
-    async createCustomerForTeam(user: User, team: Team): Promise<string> {
-        const attributionId = AttributionId.render({ kind: "team", teamId: team.id });
-        if (await this.findCustomerByAttributionId(attributionId)) {
-            throw new Error(`A Stripe customer already exists for team '${team.id}'`);
-        }
-        // Create the customer in Stripe
-        const userName = User.getName(user);
-        const customer = await this.getStripe().customers.create({
-            email: User.getPrimaryEmail(user),
-            name: userName ? `${userName} (${team.name})` : team.name,
-            metadata: { attributionId },
-        });
-        // Wait for the customer to show up in Stripe search results before proceeding
-        let attempts = 0;
-        while (!(await this.findCustomerByAttributionId(attributionId))) {
-            await new Promise((resolve) => setTimeout(resolve, POLL_CREATED_CUSTOMER_INTERVAL_MS));
-            if (++attempts > POLL_CREATED_CUSTOMER_MAX_ATTEMPTS) {
-                throw new Error(`Could not confirm Stripe customer creation for team '${team.id}'`);
-            }
-        }
-        return customer.id;
-    }
-
-    async setPreferredCurrencyForCustomer(customerId: string, currency: string): Promise<void> {
-        await this.getStripe().customers.update(customerId, { metadata: { preferredCurrency: currency } });
-    }
-
     async setDefaultPaymentMethodForCustomer(customerId: string, setupIntentId: string): Promise<void> {
         const setupIntent = await this.getStripe().setupIntents.retrieve(setupIntentId);
         if (typeof setupIntent.payment_method !== "string") {

components/server/ee/src/workspace/gitpod-server-impl.ts

@@ -2076,8 +2076,8 @@ export class GitpodServerEEImpl extends GitpodServerImpl {
         }
     }
 
-    async createStripeCustomer(ctx: TraceContext, attributionId: string, currency: string): Promise<void> {
-        const user = this.checkAndBlockUser("createStripeCustomer");
+    async createStripeCustomerIfNeeded(ctx: TraceContext, attributionId: string, currency: string): Promise<void> {
+        const user = this.checkAndBlockUser("createStripeCustomerIfNeeded");
         const attrId = AttributionId.parse(attributionId);
         if (!attrId) {
             throw new ResponseError(ErrorCodes.BAD_REQUEST, `Invalid attributionId '${attributionId}'`);
@@ -2096,17 +2096,16 @@ export class GitpodServerEEImpl extends GitpodServerImpl {
             await this.ensureStripeApiIsAllowed({ user });
         }
         try {
-            if (await this.stripeService.findCustomerByAttributionId(attributionId)) {
-                throw new ResponseError(
-                    ErrorCodes.BAD_REQUEST,
-                    "A Stripe customer profile already exists for this attributionId",
+            if (!(await this.stripeService.findCustomerByAttributionId(attributionId))) {
+                const billingEmail = User.getPrimaryEmail(user);
+                const billingName = attrId.kind === "team" ? team!.name : User.getName(user);
+                await this.stripeService.createCustomerForAttributionId(
+                    attributionId,
+                    currency,
+                    billingEmail,
+                    billingName,
                 );
             }
-            const customerId =
-                attrId.kind === "team"
-                    ? await this.stripeService.createCustomerForTeam(user, team!)
-                    : await this.stripeService.createCustomerForUser(user);
-            await this.stripeService.setPreferredCurrencyForCustomer(customerId, currency);
         } catch (error) {
             log.error(`Failed to create Stripe customer profile for '${attributionId}'`, error);
             throw new ResponseError(

components/server/src/auth/rate-limiter.ts

@@ -201,7 +201,7 @@ const defaultFunctions: FunctionsConfig = {
     getStripePublishableKey: { group: "default", points: 1 },
     getStripeSetupIntentClientSecret: { group: "default", points: 1 },
     findStripeSubscriptionId: { group: "default", points: 1 },
-    createStripeCustomer: { group: "default", points: 1 },
+    createStripeCustomerIfNeeded: { group: "default", points: 1 },
     subscribeToStripe: { group: "default", points: 1 },
     getStripePortalUrl: { group: "default", points: 1 },
     listUsage: { group: "default", points: 1 },

components/server/src/workspace/gitpod-server-impl.ts

@@ -3130,7 +3130,7 @@ export class GitpodServerImpl implements GitpodServerWithTracing, Disposable {
     async findStripeSubscriptionId(ctx: TraceContext, attributionId: string): Promise<string | undefined> {
         throw new ResponseError(ErrorCodes.SAAS_FEATURE, `Not implemented in this version`);
     }
-    async createStripeCustomer(ctx: TraceContext, attributionId: string, currency: string): Promise<void> {
+    async createStripeCustomerIfNeeded(ctx: TraceContext, attributionId: string, currency: string): Promise<void> {
         throw new ResponseError(ErrorCodes.SAAS_FEATURE, `Not implemented in this version`);
     }
     async subscribeToStripe(ctx: TraceContext, attributionId: string, setupIntentId: string): Promise<void> {