@hartl-services/medusa-affiliate 0.3.0

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

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerAffiliateAssignmentManager = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const affiliate_attribution_policy_1 = require("../domain/affiliate-attribution-policy");
+class CustomerAffiliateAssignmentManager {
+    constructor(store, affiliateService, slugService) {
+        this.store = store;
+        this.affiliateService = affiliateService;
+        this.slugService = slugService;
+    }
+    async getActiveAssignment(customerId, context) {
+        return await this.getValidAssignmentByIdentity({ customer_id: customerId }, new Date(), context);
+    }
+    async getActiveAssignmentByIdentity(input, context) {
+        return await this.getValidAssignmentByIdentity(input, new Date(), context);
+    }
+    async getValidAssignmentByIdentity(input, now = new Date(), context) {
+        const assignment = await this.findActiveAssignmentByIdentity(input, context, now);
+        return assignment ? await this.attachAffiliate(assignment, context) : null;
+    }
+    async findActiveAssignmentByIdentity(input, context, now = new Date()) {
+        const [customerAssignments, emailAssignments] = await Promise.all([
+            input.customer_id
+                ? this.store.listCustomerAffiliateAssignments({ customer_id: input.customer_id, active: true }, { order: { assigned_at: "DESC" } }, context)
+                : Promise.resolve([]),
+            input.normalized_email
+                ? this.store.listCustomerAffiliateAssignments({ normalized_email: input.normalized_email, active: true }, { order: { assigned_at: "DESC" } }, context)
+                : Promise.resolve([]),
+        ]);
+        const candidates = Array.from(new Map([...customerAssignments, ...emailAssignments].map((assignment) => [
+            assignment.id,
+            assignment,
+        ])).values());
+        const expiredCandidates = candidates.filter((assignment) => this.isExpired(assignment, now));
+        for (const assignment of expiredCandidates) {
+            await this.endAssignment(assignment.id, "expired", context, now);
+        }
+        if (expiredCandidates.length) {
+            await this.store.flush(context);
+        }
+        const validCandidates = candidates.filter((assignment) => !this.isExpired(assignment, now));
+        const newest = (assignments) => [...assignments].sort((left, right) => {
+            const assignedAtDifference = new Date(right.assigned_at).getTime() -
+                new Date(left.assigned_at).getTime();
+            return assignedAtDifference || left.id.localeCompare(right.id);
+        })[0];
+        const customerAssignment = input.customer_id
+            ? newest(validCandidates.filter((assignment) => assignment.customer_id === input.customer_id))
+            : undefined;
+        const emailAssignment = input.normalized_email
+            ? newest(validCandidates.filter((assignment) => assignment.normalized_email === input.normalized_email))
+            : undefined;
+        if (customerAssignment &&
+            emailAssignment &&
+            customerAssignment.affiliate_id !== emailAssignment.affiliate_id) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Customer and email are assigned to different affiliates.");
+        }
+        if (customerAssignment &&
+            emailAssignment &&
+            customerAssignment.id !== emailAssignment.id) {
+            // Preserve the customer-precedence row as the identity's live record.
+            // The email-only row remains historical so attribution/redemption FKs
+            // continue to reference the exact row that existed at the time.
+            await this.endAssignment(emailAssignment.id, "same_affiliate_identity_consolidated", context, now);
+            await this.store.flush(context);
+        }
+        return customerAssignment ?? emailAssignment ?? null;
+    }
+    /**
+     * Order ingestion is the authoritative point for linking a guest
+     * email-assignment to the now known Customer ID. It never changes the
+     * affiliate and therefore cannot be used as a reassignment path.
+     */
+    async resolveAssignmentForOrderIdentity(input, context) {
+        const assignment = await this.getValidAssignmentByIdentity(input, new Date(), context);
+        return assignment
+            ? await this.attachMissingIdentity(assignment, input, context)
+            : null;
+    }
+    /**
+     * Checkout identity attachment is deliberately non-reassigning. Only the
+     * Admin-facing assignCustomer path below may end and replace an assignment.
+     */
+    async assignIdentity(input, context) {
+        if (!input.customer_id && !input.normalized_email) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "A customer ID or normalized email is required.");
+        }
+        if (input.customer_id) {
+            await this.assertCustomerIsNotAffiliate(input.customer_id, context);
+        }
+        const affiliate = await this.store.retrieveAffiliate(input.affiliate_id, context);
+        this.affiliateService.assertAffiliateIsActive(affiliate);
+        return await this.createAssignmentFromAffiliate({ ...input, affiliate }, context);
+    }
+    async createAssignmentFromAffiliate(input, context) {
+        this.affiliateService.assertAffiliateIsActive(input.affiliate);
+        const now = input.assigned_at ?? new Date();
+        const activeAssignment = await this.getValidAssignmentByIdentity(input, now, context);
+        if (activeAssignment) {
+            if (activeAssignment.affiliate_id !== input.affiliate.id) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "This customer identity is already assigned to another affiliate.");
+            }
+            return {
+                assignment: await this.attachMissingIdentity(activeAssignment, input, context),
+                created: false,
+            };
+        }
+        if (input.affiliate.customer_assignment_mode === "order_only") {
+            return { assignment: null, created: false };
+        }
+        const validUntil = (0, affiliate_attribution_policy_1.calculateAssignmentValidUntil)({
+            customer_assignment_mode: input.affiliate.customer_assignment_mode,
+            assignment_duration_days: input.affiliate.assignment_duration_days,
+            assigned_at: now,
+            existing_assignment: null,
+        });
+        const created = await this.store.createCustomerAffiliateAssignments({
+            customer_id: input.customer_id ?? null,
+            normalized_email: input.normalized_email ?? null,
+            affiliate_id: input.affiliate.id,
+            source: input.source,
+            active: true,
+            assigned_at: now,
+            customer_assignment_mode: input.affiliate.customer_assignment_mode,
+            assignment_duration_days: input.affiliate.assignment_duration_days,
+            valid_until: validUntil ?? null,
+            ended_at: null,
+            ended_reason: null,
+            metadata: input.metadata ?? null,
+        }, context);
+        return {
+            assignment: await this.attachAffiliate(created, context),
+            created: true,
+        };
+    }
+    async assignCustomer(input, context) {
+        await this.assertCustomerIsNotAffiliate(input.customer_id, context);
+        const affiliate = await this.store.retrieveAffiliate(input.affiliate_id, context);
+        this.affiliateService.assertAffiliateIsActive(affiliate);
+        if (affiliate.customer_assignment_mode === "order_only") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "An order_only affiliate cannot be assigned manually.");
+        }
+        const assignedAt = new Date();
+        const candidates = await this.listActiveAssignmentsByIdentity(input, context);
+        const validAffiliates = new Set(candidates
+            .filter((candidate) => !this.isExpired(candidate, assignedAt))
+            .map((candidate) => candidate.affiliate_id));
+        if (validAffiliates.size > 1) {
+            for (const candidate of candidates) {
+                await this.endAssignment(candidate.id, "reassigned", context, assignedAt);
+            }
+            await this.store.flush(context);
+        }
+        const activeAssignment = await this.getValidAssignmentByIdentity({
+            customer_id: input.customer_id,
+            normalized_email: input.normalized_email,
+        }, assignedAt, context);
+        if (activeAssignment?.affiliate_id === affiliate.id) {
+            return await this.attachMissingIdentity(activeAssignment, input, context);
+        }
+        if (activeAssignment) {
+            await this.endAssignment(activeAssignment.id, "reassigned", context, assignedAt);
+        }
+        let created;
+        try {
+            const result = await this.createAssignmentFromAffiliate({
+                ...input,
+                affiliate,
+                assigned_at: assignedAt,
+            }, context);
+            if (!result.assignment) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "A manual assignment unexpectedly produced no persistent assignment.");
+            }
+            created = result.assignment;
+        }
+        catch (error) {
+            // The facade owns a transaction for every Admin mutation. Once an
+            // INSERT fails, PostgreSQL rejects any recovery read in that same
+            // transaction; rethrow so the transaction rolls the prior end back.
+            if (context?.transactionManager) {
+                throw error;
+            }
+            // Two concurrent requests can both pass the activeAssignment check
+            // above; the DB's partial unique index on (customer_id) where
+            // active = true then lets only one insert through. Resolve the race
+            // instead of surfacing the loser's constraint-violation error as-is.
+            const concurrentAssignment = await this.getActiveAssignment(input.customer_id, context);
+            if (!concurrentAssignment) {
+                throw error;
+            }
+            if (concurrentAssignment.affiliate_id === affiliate.id) {
+                return concurrentAssignment;
+            }
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Customer was concurrently assigned to a different affiliate. Please retry.");
+        }
+        return await this.attachAffiliate(created, context);
+    }
+    async removeActiveAssignment(input, context) {
+        const candidates = await this.listActiveAssignmentsByIdentity(input, context);
+        const activeAffiliates = new Set(candidates.map((candidate) => candidate.affiliate_id));
+        if (activeAffiliates.size > 1) {
+            const ended = await Promise.all(candidates.map((candidate) => this.endAssignment(candidate.id, input.ended_reason, context)));
+            await this.store.flush(context);
+            return ended[0] ?? null;
+        }
+        const activeAssignment = await this.getValidAssignmentByIdentity(input, new Date(), context);
+        if (!activeAssignment) {
+            return null;
+        }
+        return await this.endAssignment(activeAssignment.id, input.ended_reason, context);
+    }
+    async listAssignmentHistory(customerId, context) {
+        const now = new Date();
+        const assignments = await this.store.listCustomerAffiliateAssignments({ customer_id: customerId }, { order: { assigned_at: "DESC" } }, context);
+        return await Promise.all(assignments.map((assignment) => assignment.active && this.isExpired(assignment, now)
+            ? this.endAssignment(assignment.id, "expired", context, now)
+            : this.attachAffiliate(assignment, context)));
+    }
+    async expireAssignmentsBatch(input = {}, context) {
+        const now = input.now ?? new Date();
+        const assignments = await this.store.listCustomerAffiliateAssignments({ active: true, valid_until: { $lte: now } }, { take: input.limit ?? 100, order: { assigned_at: "ASC" } }, context);
+        return await Promise.all(assignments.map((assignment) => this.endAssignment(assignment.id, "expired", context, now)));
+    }
+    async expireOpenAssignmentsBatch(now, limit, context) {
+        const assignments = await this.store.listCustomerAffiliateAssignments({ active: true, valid_until: { $lte: now } }, { take: limit + 1, order: { assigned_at: "ASC" } }, context);
+        const due = assignments.slice(0, limit);
+        let processed = 0;
+        for (const assignment of due) {
+            const updated = await this.store.updateCustomerAffiliateAssignments({
+                selector: {
+                    id: assignment.id,
+                    active: true,
+                    valid_until: { $lte: now },
+                },
+                data: {
+                    active: false,
+                    ended_at: now,
+                    ended_reason: "expired",
+                },
+            }, context);
+            processed += Array.isArray(updated)
+                ? updated.length
+                : Number(Boolean(updated));
+        }
+        return { processed, has_more: assignments.length > limit };
+    }
+    /**
+     * Ends every active assignment when a customer becomes an affiliate.
+     * Historical attribution remains auditable.
+     */
+    async deleteAssignmentsForCustomer(customerId, context) {
+        const assignments = await this.store.listCustomerAffiliateAssignments({
+            customer_id: customerId,
+            active: true,
+        }, undefined, context);
+        if (assignments.length) {
+            for (const assignment of assignments) {
+                await this.endAssignment(assignment.id, "customer_became_affiliate", context);
+            }
+        }
+    }
+    async removeAssignmentsForAffiliate(affiliateId, reason = "affiliate_inactive", context, now = new Date()) {
+        const activeAssignments = await this.store.listCustomerAffiliateAssignments({
+            affiliate_id: affiliateId,
+            active: true,
+        }, undefined, context);
+        const endedAssignments = [];
+        for (const assignment of activeAssignments) {
+            const updated = await this.store.updateCustomerAffiliateAssignments({
+                selector: { id: assignment.id, active: true },
+                data: { active: false, ended_at: now, ended_reason: reason },
+            }, context);
+            const ended = Array.isArray(updated) ? updated[0] : updated;
+            if (ended) {
+                endedAssignments.push(await this.attachAffiliate(ended, context));
+            }
+        }
+        return endedAssignments;
+    }
+    async isCustomerAffiliate(customerId) {
+        const affiliates = await this.store.listAffiliates({
+            customer_id: customerId,
+        });
+        return affiliates.some((affiliate) => affiliate.status !== "rejected");
+    }
+    async assertCustomerIsNotAffiliate(customerId, context) {
+        const affiliates = await this.store.listAffiliates({ customer_id: customerId }, undefined, context);
+        if (affiliates.some((affiliate) => affiliate.status !== "rejected")) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "This customer is a registered affiliate and cannot be assigned a referring affiliate.");
+        }
+    }
+    async endAssignment(assignmentId, reason, context, endedAt = new Date()) {
+        const updated = (await this.store.updateCustomerAffiliateAssignments({
+            id: assignmentId,
+            active: false,
+            ended_at: endedAt,
+            ended_reason: reason,
+        }, context));
+        return await this.attachAffiliate(updated, context);
+    }
+    async listActiveAssignmentsByIdentity(input, context) {
+        const [customerAssignments, emailAssignments] = await Promise.all([
+            input.customer_id
+                ? this.store.listCustomerAffiliateAssignments({ customer_id: input.customer_id, active: true }, undefined, context)
+                : Promise.resolve([]),
+            input.normalized_email
+                ? this.store.listCustomerAffiliateAssignments({ normalized_email: input.normalized_email, active: true }, undefined, context)
+                : Promise.resolve([]),
+        ]);
+        return Array.from(new Map([...customerAssignments, ...emailAssignments].map((assignment) => [
+            assignment.id,
+            assignment,
+        ])).values());
+    }
+    isExpired(assignment, now) {
+        return (assignment.valid_until !== null &&
+            new Date(assignment.valid_until).getTime() <= now.getTime());
+    }
+    async attachMissingIdentity(assignment, input, context) {
+        if ((input.customer_id &&
+            assignment.customer_id &&
+            input.customer_id !== assignment.customer_id) ||
+            (input.normalized_email &&
+                assignment.normalized_email &&
+                input.normalized_email !== assignment.normalized_email)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "Customer identity does not match its existing affiliate assignment.");
+        }
+        const missingCustomerId = input.customer_id && !assignment.customer_id;
+        const missingEmail = input.normalized_email && !assignment.normalized_email;
+        if (!missingCustomerId && !missingEmail) {
+            return assignment;
+        }
+        const updated = (await this.store.updateCustomerAffiliateAssignments({
+            id: assignment.id,
+            ...(missingCustomerId ? { customer_id: input.customer_id } : {}),
+            ...(missingEmail ? { normalized_email: input.normalized_email } : {}),
+        }, context));
+        return await this.attachAffiliate(updated, context);
+    }
+    async attachAffiliate(assignment, context) {
+        const affiliate = await this.affiliateService.retrieveAffiliateWithSlugs(assignment.affiliate_id, context);
+        return {
+            ...assignment,
+            affiliate,
+        };
+    }
+}
+exports.CustomerAffiliateAssignmentManager = CustomerAffiliateAssignmentManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customer-affiliate-assignment-manager.js","sourceRoot":"","sources":["../../../../../../src/modules/affiliate/services/customer-affiliate-assignment-manager.ts"],"names":[],"mappings":"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"}