@hartl-services/medusa-affiliate 0.3.0

package/.medusa/server/src/modules/affiliate/services/affiliate-application-manager.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AffiliateApplicationManager = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const utils_2 = require("./utils");
+class AffiliateApplicationManager {
+    constructor(store, affiliateService, slugService) {
+        this.store = store;
+        this.affiliateService = affiliateService;
+        this.slugService = slugService;
+    }
+    async submitApplication(input) {
+        const pendingApplications = await this.store.listAffiliateApplications({
+            customer_id: input.customer_id,
+            status: "pending",
+        });
+        if (pendingApplications.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Customer already has a pending affiliate application.");
+        }
+        const existingAffiliates = await this.store.listAffiliates({
+            customer_id: input.customer_id,
+        });
+        if (existingAffiliates.some((affiliate) => affiliate.status !== "rejected")) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Customer is already linked to an affiliate.");
+        }
+        try {
+            return await this.store.createAffiliateApplications({
+                customer_id: input.customer_id,
+                display_name: input.display_name.trim(),
+                requested_slug: input.requested_slug ? this.slugService.normalizeSlug(input.requested_slug) : null,
+                status: "pending",
+                message: (0, utils_2.parseOptionalText)(input.message),
+                rejection_reason: null,
+                affiliate_id: null,
+                reviewed_by_id: null,
+                reviewed_at: null,
+                metadata: input.metadata ?? null,
+            });
+        }
+        catch (error) {
+            // Two concurrent submissions can both pass the pendingApplications
+            // check above; IDX_affiliate_application_unique_pending_customer then
+            // lets only one insert through. Resolve the race instead of surfacing
+            // the loser's constraint-violation error as-is.
+            const concurrentApplication = (await this.store.listAffiliateApplications({
+                customer_id: input.customer_id,
+                status: "pending",
+            }))[0];
+            if (!concurrentApplication) {
+                throw error;
+            }
+            return concurrentApplication;
+        }
+    }
+    async approveApplication(input, context) {
+        const application = await this.store.retrieveAffiliateApplication(input.application_id, context);
+        this.assertPending(application);
+        const affiliate = await this.approveAsAffiliate(application, input, context);
+        const updatedApplication = await this.store.updateAffiliateApplications({
+            id: application.id,
+            status: "approved",
+            affiliate_id: affiliate.id,
+            reviewed_by_id: input.reviewed_by_id ?? null,
+            reviewed_at: new Date(),
+        }, context);
+        return {
+            application: updatedApplication,
+            affiliate,
+        };
+    }
+    async approveAsAffiliate(application, input, context) {
+        // A customer can only ever own one non-deleted affiliate row (see
+        // IDX_affiliate_unique_customer), so submitApplication allowing
+        // resubmission after a "rejected" affiliate means that row, not a new
+        // one, must be reactivated here to avoid a unique-constraint collision.
+        const existingAffiliate = application.customer_id
+            ? (await this.store.listAffiliates({ customer_id: application.customer_id }, undefined, context))[0] ?? null
+            : null;
+        if (!existingAffiliate) {
+            return await this.affiliateService.createAffiliate({
+                display_name: application.display_name,
+                customer_id: application.customer_id,
+                status: "active",
+                commission_rate: input.commission_rate,
+                own_order_discount_rate: input.own_order_discount_rate,
+                slug: input.slug ?? application.requested_slug,
+                referred_by_affiliate_id: input.referred_by_affiliate_id ?? null,
+                referrer_commission_rate: input.referrer_commission_rate ?? null,
+                internal_notes: input.internal_notes ?? null,
+                metadata: application.metadata ?? null,
+            }, context);
+        }
+        const reactivated = await this.affiliateService.updateAffiliate({
+            id: existingAffiliate.id,
+            display_name: application.display_name,
+            status: "active",
+            commission_rate: input.commission_rate,
+            own_order_discount_rate: input.own_order_discount_rate,
+            referred_by_affiliate_id: input.referred_by_affiliate_id ?? null,
+            referrer_commission_rate: input.referrer_commission_rate ?? null,
+            internal_notes: input.internal_notes ?? null,
+            metadata: application.metadata ?? null,
+        }, context);
+        const requestedSlug = input.slug ?? application.requested_slug;
+        if (!requestedSlug) {
+            return reactivated;
+        }
+        const normalizedSlug = this.slugService.normalizeSlug(requestedSlug);
+        const alreadyOwnsSlug = reactivated.slugs?.some((existingSlug) => existingSlug.slug === normalizedSlug);
+        if (alreadyOwnsSlug) {
+            return reactivated;
+        }
+        await this.slugService.createSlug({
+            affiliate_id: reactivated.id,
+            slug: normalizedSlug,
+            is_primary: true,
+        }, context);
+        return await this.affiliateService.retrieveAffiliateWithSlugs(reactivated.id, context);
+    }
+    async rejectApplication(input) {
+        const application = await this.store.retrieveAffiliateApplication(input.application_id);
+        this.assertPending(application);
+        const affiliate = await this.rejectAsAffiliate(application);
+        return await this.store.updateAffiliateApplications({
+            id: application.id,
+            status: "rejected",
+            affiliate_id: affiliate.id,
+            rejection_reason: (0, utils_2.parseOptionalText)(input.rejection_reason),
+            reviewed_by_id: input.reviewed_by_id ?? null,
+            reviewed_at: new Date(),
+        });
+    }
+    async rejectAsAffiliate(application) {
+        // A customer can only ever own one non-deleted affiliate row (see
+        // IDX_affiliate_unique_customer), and submitApplication only lets a
+        // customer resubmit while their existing affiliate is already
+        // "rejected" — so an existing row found here is already in that state.
+        // Keeping (rather than recreating) it is what makes the row show up,
+        // and stay reactivatable, in the main affiliates list.
+        const existingAffiliate = (await this.store.listAffiliates({ customer_id: application.customer_id }))[0] ?? null;
+        if (existingAffiliate) {
+            return existingAffiliate;
+        }
+        return await this.affiliateService.createAffiliate({
+            display_name: application.display_name,
+            customer_id: application.customer_id,
+            status: "rejected",
+            commission_rate: 0,
+            own_order_discount_rate: 0,
+            metadata: application.metadata ?? null,
+        });
+    }
+    async listApplications(input) {
+        return await this.store.listAndCountAffiliateApplications({
+            ...(input.status ? { status: input.status } : {}),
+        }, {
+            skip: input.offset,
+            take: input.limit,
+            order: {
+                created_at: "DESC",
+            },
+        });
+    }
+    assertPending(application) {
+        if (application.status !== "pending") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Affiliate application has already been reviewed.");
+        }
+    }
+}
+exports.AffiliateApplicationManager = AffiliateApplicationManager;
+//# sourceMappingURL=data:application/json;base64,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