@hartl-services/medusa-affiliate 0.3.0

package/.medusa/server/src/modules/affiliate/services/affiliate-report.service.js

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AffiliateReportService = void 0;
+const money_1 = require("../../../utils/money");
+const utils_1 = require("./utils");
+class AffiliateReportService {
+    constructor(store) {
+        this.store = store;
+        /**
+         * Commission entries for a date range are fetched a page at a time and
+         * folded into the running totals map instead of loading the whole range
+         * into memory at once, so peak memory is bounded by the batch size and the
+         * number of distinct affiliate/currency groups, not by entry count.
+         */
+        this.overviewBatchSize = 500;
+    }
+    /**
+     * Portal-only aggregation over the immutable ledger. The Admin report keeps
+     * its existing accumulator below; both paths share the same bounded scanner.
+     */
+    async getPortalLedgerTotals(input) {
+        const from = (0, utils_1.startOfUtcDate)(input.from);
+        const to = (0, utils_1.endOfUtcDate)(input.to);
+        const totals = new Map();
+        await this.forEachAttributionInRange({ from, to, affiliate_id: input.affiliate_id }, (batch) => {
+            for (const attribution of batch) {
+                const current = this.getPortalGroup(totals, attribution.currency_code);
+                // order_id is permanently unique on the immutable attribution model,
+                // so every live row is one distinct attributed order.
+                current.attributed_order_count += 1;
+            }
+        });
+        await this.forEachEntryInRange({ from, to, affiliate_id: input.affiliate_id }, (batch) => {
+            for (const entry of batch) {
+                const current = this.getPortalGroup(totals, entry.currency_code);
+                const amount = money_1.Money.of(entry.commission_amount);
+                if (entry.type === "order_commission") {
+                    current.direct = current.direct.add(amount);
+                    current.base = current.base.add(money_1.Money.of(entry.base_amount_net));
+                }
+                else if (entry.type === "affiliate_referral_bonus" ||
+                    entry.type === "affiliate_own_order_referrer_bonus") {
+                    current.referral = current.referral.add(amount);
+                }
+                else if (entry.type === "refund_correction" ||
+                    entry.type === "cancellation_correction" ||
+                    entry.type === "manual_correction") {
+                    current.correction = current.correction.add(amount);
+                }
+            }
+        });
+        await this.forEachDirectCommissionOrderInRange({ from, to, affiliate_id: input.affiliate_id }, (batch) => {
+            for (const entry of batch) {
+                if (entry.commission_amount <= 0)
+                    continue;
+                const current = this.getPortalGroup(totals, entry.currency_code);
+                current.commissioned_order_count += 1;
+            }
+        });
+        return Array.from(totals.values())
+            .map((total) => {
+            const decimals = (0, money_1.getCurrencyDecimals)(total.currency_code);
+            return {
+                currency_code: total.currency_code,
+                direct_commission_amount: total.direct.toRoundedNumber(decimals),
+                referral_commission_amount: total.referral.toRoundedNumber(decimals),
+                correction_amount: total.correction.toRoundedNumber(decimals),
+                net_commission_amount: total.direct
+                    .add(total.referral)
+                    .add(total.correction)
+                    .toRoundedNumber(decimals),
+                commission_base_amount: total.base.toRoundedNumber(decimals),
+                attributed_order_count: total.attributed_order_count,
+                commissioned_order_count: total.commissioned_order_count
+            };
+        })
+            .sort((a, b) => a.currency_code.localeCompare(b.currency_code));
+    }
+    async getPortalLedgerPage(input) {
+        const from = (0, utils_1.startOfUtcDate)(input.from);
+        const to = (0, utils_1.endOfUtcDate)(input.to);
+        let count = 0;
+        await this.forEachEntryInRange({ from, to, affiliate_id: input.affiliate_id }, (batch) => {
+            count += batch.length;
+        });
+        const [totals, entries] = await Promise.all([
+            this.getPortalLedgerTotals(input),
+            this.store.listCommissionEntries({
+                affiliate_id: input.affiliate_id,
+                occurred_at: { $gte: from, $lte: to }
+            }, {
+                order: { occurred_at: "DESC", id: "DESC" },
+                skip: input.offset,
+                take: input.limit
+            })
+        ]);
+        return { entries, count, totals };
+    }
+    async getOverview(input) {
+        const from = (0, utils_1.startOfUtcDate)(input.from);
+        const to = (0, utils_1.endOfUtcDate)(input.to);
+        const totals = new Map();
+        const affiliateIds = new Set();
+        await this.forEachAttributionInRange({ from, to }, (batch) => {
+            for (const attribution of batch) {
+                affiliateIds.add(attribution.affiliate_id);
+                const current = this.getReportGroup(totals, {
+                    affiliate_id: attribution.affiliate_id,
+                    currency_code: attribution.currency_code
+                }, this.reportGroupKey(attribution.affiliate_id, attribution.currency_code));
+                // The storage model enforces one live immutable attribution per order.
+                current.attributed_order_count += 1;
+            }
+        });
+        await this.forEachDirectCommissionOrderInRange({ from, to }, (batch) => {
+            for (const entry of batch) {
+                if (entry.commission_amount <= 0)
+                    continue;
+                const current = this.getReportGroup(totals, {
+                    affiliate_id: entry.affiliate_id,
+                    currency_code: entry.currency_code
+                }, this.reportGroupKey(entry.affiliate_id, entry.currency_code));
+                current.commissioned_order_count += 1;
+                current.order_count += 1;
+            }
+        });
+        await this.forEachBonusOnlyOrderInRange({ from, to }, (batch) => {
+            for (const entry of batch) {
+                if (entry.commission_amount <= 0)
+                    continue;
+                const current = this.getReportGroup(totals, {
+                    affiliate_id: entry.affiliate_id,
+                    currency_code: entry.currency_code
+                }, this.reportGroupKey(entry.affiliate_id, entry.currency_code));
+                current.order_count += 1;
+            }
+        });
+        await this.forEachEntryInRange({ from, to }, (batch) => {
+            this.accumulateEntriesInto(totals, batch, (entry) => {
+                affiliateIds.add(entry.affiliate_id);
+                return {
+                    affiliate_id: entry.affiliate_id,
+                    currency_code: entry.currency_code
+                };
+            });
+        });
+        const affiliates = affiliateIds.size
+            ? await this.store.listAffiliates({ id: Array.from(affiliateIds) })
+            : [];
+        const affiliatesById = new Map(affiliates.map((affiliate) => [affiliate.id, affiliate]));
+        const overviewItems = this.finalizeTotals(totals).map((total) => ({
+            ...total,
+            display_name: affiliatesById.get(total.affiliate_id)?.display_name ??
+                total.affiliate_id,
+            status: affiliatesById.get(total.affiliate_id)?.status ?? "inactive"
+        }));
+        return {
+            from: from.toISOString().slice(0, 10),
+            to: to.toISOString().slice(0, 10),
+            affiliates: overviewItems.sort((a, b) => a.display_name.localeCompare(b.display_name))
+        };
+    }
+    async getDetail(input) {
+        const from = (0, utils_1.startOfUtcDate)(input.from);
+        const to = (0, utils_1.endOfUtcDate)(input.to);
+        const affiliate = await this.store.retrieveAffiliate(input.affiliate_id);
+        // Totals are accumulated over the whole range in bounded batches so they
+        // stay correct even though only one page of entries is loaded for display.
+        const totals = new Map();
+        let entriesCount = 0;
+        await this.forEachAttributionInRange({ from, to, affiliate_id: input.affiliate_id }, (batch) => {
+            for (const attribution of batch) {
+                const current = this.getReportGroup(totals, {
+                    currency_code: attribution.currency_code
+                }, this.reportGroupKey(attribution.affiliate_id, attribution.currency_code));
+                current.attributed_order_count += 1;
+            }
+        });
+        await this.forEachEntryInRange({ from, to, affiliate_id: input.affiliate_id }, (batch) => {
+            entriesCount += batch.length;
+            this.accumulateEntriesInto(totals, batch, (entry) => ({
+                currency_code: entry.currency_code
+            }));
+        });
+        await this.forEachDirectCommissionOrderInRange({ from, to, affiliate_id: input.affiliate_id }, (batch) => {
+            for (const entry of batch) {
+                if (entry.commission_amount <= 0)
+                    continue;
+                const current = this.getReportGroup(totals, { currency_code: entry.currency_code }, this.reportGroupKey(entry.affiliate_id, entry.currency_code));
+                current.commissioned_order_count += 1;
+                current.order_count += 1;
+            }
+        });
+        await this.forEachBonusOnlyOrderInRange({ from, to, affiliate_id: input.affiliate_id }, (batch) => {
+            for (const entry of batch) {
+                if (entry.commission_amount <= 0)
+                    continue;
+                const current = this.getReportGroup(totals, { currency_code: entry.currency_code }, this.reportGroupKey(entry.affiliate_id, entry.currency_code));
+                current.order_count += 1;
+            }
+        });
+        const entries = await this.store.listCommissionEntries({
+            affiliate_id: input.affiliate_id,
+            occurred_at: {
+                $gte: from,
+                $lte: to
+            }
+        }, {
+            order: {
+                occurred_at: "DESC",
+                id: "DESC"
+            },
+            skip: input.offset,
+            take: input.limit
+        });
+        return {
+            from: from.toISOString().slice(0, 10),
+            to: to.toISOString().slice(0, 10),
+            affiliate,
+            entries,
+            entries_count: entriesCount,
+            totals: this.finalizeTotals(totals)
+        };
+    }
+    /**
+     * Scans every commission entry in the range in bounded batches using keyset
+     * pagination on the unique `id` (stable: no row is skipped or double-counted
+     * across batch boundaries the way an occurred_at skip/take would when several
+     * entries share a timestamp). The aggregation is order-independent, so a plain
+     * `id ASC` cursor is sufficient.
+     */
+    async forEachEntryInRange(range, onBatch) {
+        let cursor;
+        for (;;) {
+            const batch = await this.store.listCommissionEntries({
+                ...(range.affiliate_id ? { affiliate_id: range.affiliate_id } : {}),
+                occurred_at: {
+                    $gte: range.from,
+                    $lte: range.to
+                },
+                ...(cursor ? { id: { $gt: cursor } } : {})
+            }, {
+                order: {
+                    id: "ASC"
+                },
+                take: this.overviewBatchSize
+            });
+            if (!batch.length) {
+                return;
+            }
+            onBatch(batch);
+            if (batch.length < this.overviewBatchSize) {
+                return;
+            }
+            cursor = batch[batch.length - 1].id;
+        }
+    }
+    /** Scans immutable attribution snapshots with the same bounded keyset rule. */
+    async forEachAttributionInRange(range, onBatch) {
+        let cursor;
+        for (;;) {
+            const batch = await this.store.listAffiliateOrderAttributions({
+                ...(range.affiliate_id ? { affiliate_id: range.affiliate_id } : {}),
+                attributed_at: { $gte: range.from, $lte: range.to },
+                ...(cursor ? { id: { $gt: cursor } } : {})
+            }, { order: { id: "ASC" }, take: this.overviewBatchSize });
+            if (!batch.length)
+                return;
+            onBatch(batch);
+            if (batch.length < this.overviewBatchSize)
+                return;
+            cursor = batch[batch.length - 1].id;
+        }
+    }
+    /**
+     * Counts positive direct commissions by a bounded `order_id` keyset rather
+     * than retaining every order ID. Direct order-commission rows are immutable
+     * one-per-order bookings (`oc:<order_id>`); the order keyset also preserves
+     * the distinct-order result for legacy duplicate rows without unbounded
+     * process memory. Generated service reads exclude soft-deleted history.
+     */
+    async forEachDirectCommissionOrderInRange(range, onBatch) {
+        let cursor;
+        for (;;) {
+            const batch = await this.store.listCommissionEntries({
+                ...(range.affiliate_id ? { affiliate_id: range.affiliate_id } : {}),
+                type: "order_commission",
+                occurred_at: { $gte: range.from, $lte: range.to },
+                ...(cursor ? { order_id: { $gt: cursor } } : {})
+            }, {
+                order: { order_id: "ASC", id: "ASC" },
+                take: this.overviewBatchSize
+            });
+            if (!batch.length)
+                return;
+            // Rows for the same order are adjacent in this query. Deduplicate only
+            // the current bounded batch; the cursor advances by order_id, so later
+            // batches cannot reintroduce a completed order.
+            const distinctOrders = batch.filter((entry, index) => index === 0 || entry.order_id !== batch[index - 1].order_id);
+            onBatch(distinctOrders);
+            if (batch.length < this.overviewBatchSize)
+                return;
+            cursor = batch[batch.length - 1].order_id ?? undefined;
+            if (!cursor)
+                return;
+        }
+    }
+    /**
+     * Same bounded `order_id`-keyset scan as
+     * `forEachDirectCommissionOrderInRange`, but over the referral/own-order
+     * bonus types instead of `order_commission`. A given order has at most one
+     * row in this type set system-wide (the own-order-bonus path short-circuits
+     * the normal attribution flow entirely, and a regular referral bonus is
+     * bound to a single `referrer_affiliate_id`), so the same order-only,
+     * cross-affiliate-agnostic adjacent dedup stays correct: whenever both a
+     * direct and a bonus row exist for one order, they belong to two different
+     * affiliates (buyer vs. referrer), never the same one.
+     */
+    async forEachBonusOnlyOrderInRange(range, onBatch) {
+        let cursor;
+        for (;;) {
+            const batch = await this.store.listCommissionEntries({
+                ...(range.affiliate_id ? { affiliate_id: range.affiliate_id } : {}),
+                type: ["affiliate_referral_bonus", "affiliate_own_order_referrer_bonus"],
+                occurred_at: { $gte: range.from, $lte: range.to },
+                ...(cursor ? { order_id: { $gt: cursor } } : {})
+            }, {
+                order: { order_id: "ASC", id: "ASC" },
+                take: this.overviewBatchSize
+            });
+            if (!batch.length)
+                return;
+            const distinctOrders = batch.filter((entry, index) => index === 0 || entry.order_id !== batch[index - 1].order_id);
+            onBatch(distinctOrders);
+            if (batch.length < this.overviewBatchSize)
+                return;
+            cursor = batch[batch.length - 1].order_id ?? undefined;
+            if (!cursor)
+                return;
+        }
+    }
+    /**
+     * Sums commission_amount by immutable affiliate/currency snapshot into the
+     * given map. Callers can feed entries in as many batches as needed.
+     */
+    accumulateEntriesInto(totals, entries, seed) {
+        for (const entry of entries) {
+            const current = this.getReportGroup(totals, seed(entry), this.reportGroupKey(entry.affiliate_id, entry.currency_code));
+            const commissionAmount = money_1.Money.of(entry.commission_amount);
+            current.total_commission_amount =
+                current.total_commission_amount.add(commissionAmount);
+            current.entry_count += 1;
+            if (!commissionAmount.isNegative()) {
+                current.positive_commission_amount =
+                    current.positive_commission_amount.add(commissionAmount);
+            }
+            else {
+                current.negative_correction_amount =
+                    current.negative_correction_amount.add(commissionAmount);
+            }
+            // "Bestellungswert": the net basis behind every entry that actually
+            // paid out, so it stays a meaningful denominator next to the
+            // commission total (see affiliate-report.service.ts's own module
+            // docs). Zero-amount entries don't count as "earned from".
+            if (entry.commission_amount > 0) {
+                current.order_value_amount = current.order_value_amount.add(money_1.Money.of(entry.base_amount_net));
+            }
+            if (entry.type === "affiliate_referral_bonus" ||
+                entry.type === "affiliate_own_order_referrer_bonus") {
+                current.referral_bonus_amount =
+                    current.referral_bonus_amount.add(commissionAmount);
+            }
+        }
+    }
+    /**
+     * Keeps the running totals as Money values, then applies the exact decimal
+     * precision of the group's currency only at the response boundary.
+     */
+    finalizeTotals(totals) {
+        return Array.from(totals.values()).map((total) => {
+            const decimalPlaces = (0, money_1.getCurrencyDecimals)(total.currency_code);
+            return {
+                ...total,
+                total_commission_amount: total.total_commission_amount.toRoundedNumber(decimalPlaces),
+                positive_commission_amount: total.positive_commission_amount.toRoundedNumber(decimalPlaces),
+                negative_correction_amount: total.negative_correction_amount.toRoundedNumber(decimalPlaces),
+                referral_bonus_amount: total.referral_bonus_amount.toRoundedNumber(decimalPlaces),
+                order_value_amount: total.order_value_amount.toRoundedNumber(decimalPlaces),
+                attributed_order_count: total.attributed_order_count,
+                commissioned_order_count: total.commissioned_order_count,
+                order_count: total.order_count
+            };
+        });
+    }
+    getReportGroup(totals, seed, key) {
+        const current = totals.get(key);
+        if (current)
+            return current;
+        const created = {
+            ...seed,
+            total_commission_amount: money_1.Money.zero(),
+            positive_commission_amount: money_1.Money.zero(),
+            negative_correction_amount: money_1.Money.zero(),
+            referral_bonus_amount: money_1.Money.zero(),
+            order_value_amount: money_1.Money.zero(),
+            entry_count: 0,
+            attributed_order_count: 0,
+            commissioned_order_count: 0,
+            order_count: 0
+        };
+        totals.set(key, created);
+        return created;
+    }
+    /** A reversible tuple encoding prevents delimiter collisions in report maps. */
+    reportGroupKey(affiliateId, currencyCode) {
+        return JSON.stringify([affiliateId, currencyCode]);
+    }
+    getPortalGroup(totals, currencyCode) {
+        const current = totals.get(currencyCode);
+        if (current)
+            return current;
+        const created = {
+            currency_code: currencyCode,
+            direct: money_1.Money.zero(),
+            referral: money_1.Money.zero(),
+            correction: money_1.Money.zero(),
+            base: money_1.Money.zero(),
+            attributed_order_count: 0,
+            commissioned_order_count: 0
+        };
+        totals.set(currencyCode, created);
+        return created;
+    }
+}
+exports.AffiliateReportService = AffiliateReportService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"affiliate-report.service.js","sourceRoot":"","sources":["../../../../../../src/modules/affiliate/services/affiliate-report.service.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AffiliateSlugManager = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+class AffiliateSlugManager {
+    constructor(store) {
+        this.store = store;
+    }
+    normalizeSlug(value) {
+        const slug = value
+            .trim()
+            .toLowerCase()
+            .replace(/['"]/g, "")
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-+|-+$/g, "")
+            .replace(/-{2,}/g, "-");
+        if (!slug) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Affiliate slug is required.");
+        }
+        return slug;
+    }
+    async createSlug(input, context) {
+        const slug = this.normalizeSlug(input.slug);
+        // When called right after the affiliate was created in the same
+        // transaction, flush so the existence check below sees it. A filtered
+        // `list` is used rather than `retrieve` because, within an open
+        // transaction, the generated `retrieve` does not observe a row created
+        // (and flushed) earlier in the same transaction, whereas `list` does.
+        await this.store.flush(context);
+        await this.assertSlugIsAvailable(slug, undefined, context);
+        const [affiliate] = await this.store.listAffiliates({ id: input.affiliate_id }, { take: 1 }, context);
+        if (!affiliate) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Affiliate with id "${input.affiliate_id}" was not found.`);
+        }
+        const existingSlugs = await this.store.listAffiliateSlugs({
+            affiliate_id: input.affiliate_id,
+        }, undefined, context);
+        const makePrimary = existingSlugs.length === 0 || (input.is_primary ?? false);
+        const active = input.active ?? true;
+        if (makePrimary && !active) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "A primary affiliate slug must be active.");
+        }
+        const created = await this.store.createAffiliateSlugs({
+            affiliate_id: input.affiliate_id,
+            slug,
+            active,
+            is_primary: false,
+        }, context);
+        if (makePrimary) {
+            return await this.setPrimarySlug({ affiliate_id: input.affiliate_id, slug_id: created.id }, context);
+        }
+        return created;
+    }
+    async updateSlug(input, context) {
+        const [existing] = await this.store.listAffiliateSlugs({ id: input.id, affiliate_id: input.affiliate_id }, { take: 1 }, context);
+        if (!existing) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "Affiliate slug was not found for this affiliate.");
+        }
+        const nextSlug = input.slug !== undefined ? this.normalizeSlug(input.slug) : existing.slug;
+        if (nextSlug !== existing.slug) {
+            await this.assertSlugIsAvailable(nextSlug, existing.id, context);
+        }
+        const nextActive = input.active ?? existing.active;
+        const nextPrimary = input.is_primary ?? existing.is_primary;
+        if (existing.is_primary && (!nextActive || !nextPrimary)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "A primary affiliate slug must remain active and primary.");
+        }
+        if (nextPrimary && !nextActive) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "A primary affiliate slug must be active.");
+        }
+        const updated = (await this.store.updateAffiliateSlugs({
+            id: input.id,
+            slug: nextSlug,
+            active: nextActive,
+            is_primary: existing.is_primary,
+        }, context));
+        if (nextPrimary && !existing.is_primary) {
+            return await this.setPrimarySlug({ affiliate_id: input.affiliate_id, slug_id: updated.id }, context);
+        }
+        return updated;
+    }
+    async setPrimarySlug(input, context) {
+        await this.store.flush(context);
+        const [target] = await this.store.listAffiliateSlugs({ id: input.slug_id, affiliate_id: input.affiliate_id }, { take: 1 }, context);
+        if (!target) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "Affiliate slug was not found for this affiliate.");
+        }
+        if (!target.active) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "An inactive affiliate slug cannot be primary.");
+        }
+        await this.clearPrimarySlug(input.affiliate_id, context);
+        const updated = (await this.store.updateAffiliateSlugs({
+            id: target.id,
+            active: true,
+            is_primary: true,
+        }, context));
+        await this.store.updateAffiliates({
+            id: input.affiliate_id,
+            primary_slug_id: updated.id,
+        }, context);
+        return updated;
+    }
+    async listSlugs(affiliateId, context) {
+        return await this.store.listAffiliateSlugs({
+            affiliate_id: affiliateId,
+        }, {
+            order: {
+                created_at: "ASC",
+            },
+        }, context);
+    }
+    /**
+     * Normalizes and asserts a slug is free before a caller commits to a
+     * multi-row write (H3), so an affiliate row is never inserted only to have
+     * its primary slug rejected by the global unique index afterwards.
+     */
+    async assertSlugAvailable(slug, context) {
+        const normalized = this.normalizeSlug(slug);
+        await this.assertSlugIsAvailable(normalized, undefined, context);
+        return normalized;
+    }
+    async resolveActiveSlug(slugValue) {
+        const slug = this.normalizeSlug(slugValue);
+        const slugs = await this.store.listAffiliateSlugs({
+            slug,
+            active: true,
+        });
+        return slugs[0] ?? null;
+    }
+    async generateAvailableSlug(displayName, context) {
+        const base = this.normalizeSlug(displayName);
+        let candidate = base;
+        let suffix = 2;
+        while (!(await this.isSlugAvailable(candidate, undefined, context))) {
+            candidate = `${base}-${suffix}`;
+            suffix += 1;
+        }
+        return candidate;
+    }
+    async clearPrimarySlug(affiliateId, context) {
+        await this.store.updateAffiliateSlugs({
+            selector: {
+                affiliate_id: affiliateId,
+                is_primary: true,
+            },
+            data: {
+                is_primary: false,
+            },
+        }, context);
+    }
+    async isSlugAvailable(slug, currentSlugId, context) {
+        const existing = await this.store.listAffiliateSlugs({ slug }, undefined, context);
+        return existing.every((existingSlug) => existingSlug.id === currentSlugId);
+    }
+    async assertSlugIsAvailable(slug, currentSlugId, context) {
+        if (await this.isSlugAvailable(slug, currentSlugId, context)) {
+            return;
+        }
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.DUPLICATE_ERROR, `Affiliate slug "${slug}" is already in use.`);
+    }
+}
+exports.AffiliateSlugManager = AffiliateSlugManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"affiliate-slug-manager.js","sourceRoot":"","sources":["../../../../../../src/modules/affiliate/services/affiliate-slug-manager.ts"],"names":[],"mappings":"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"}