@etohq/ambassador 1.5.1-alpha.4

package/dist/services/ambassador-module-service.js

@@ -0,0 +1,972 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@etohq/framework/utils");
+const analytics_1 = require("../utils/analytics");
+const models_1 = require("../models");
+const generatedModels = {
+    Ambassador: models_1.Ambassador,
+    Program: models_1.Program,
+    Commission: models_1.Commission,
+    Reward: models_1.Reward,
+    ProgramEnrollment: models_1.ProgramEnrollment,
+    RevenueShareRule: models_1.RevenueShareRule,
+    Payout: models_1.Payout
+};
+class AmbassadorModuleService extends utils_1.ModulesSdkUtils.EtoService(generatedModels) {
+    constructor(dependencies, moduleDeclaration) {
+        // @ts-ignore
+        super(...arguments);
+        this.moduleDeclaration = moduleDeclaration;
+        this.baseRepository_ = dependencies.baseRepository;
+        this.ambassadorService_ = dependencies.ambassadorService;
+        this.programService_ = dependencies.programService;
+        this.commissionService_ = dependencies.commissionService;
+        this.rewardService_ = dependencies.rewardService;
+        this.payoutService_ = dependencies.payoutService;
+        this.programEnrollmentService_ = dependencies.programEnrollmentService;
+        this.revenueShareRuleService_ = dependencies.revenueShareRuleService;
+        this.revenueRuleResolver_ = dependencies.revenueRuleResolver;
+    }
+    // ===== AMBASSADOR METHODS (Step 2.1 Requirements) =====
+    async createAmbassador(sourceType, sourceId, data, sharedContext = {}) {
+        return await this.ambassadorService_.createAmbassador(sourceType, sourceId, data, sharedContext);
+    }
+    async getAmbassadorBySource(sourceType, sourceId, sharedContext = {}) {
+        return await this.ambassadorService_.getAmbassadorBySource(sourceType, sourceId, sharedContext);
+    }
+    // @ts-expect-error
+    async listAmbassadors(filters, config = {}, sharedContext = {}) {
+        return await this.ambassadorService_.list(filters, config, sharedContext);
+    }
+    async verifyWebsite(ambassadorId, domain, sharedContext = {}) {
+        return await this.ambassadorService_.verifyWebsite(ambassadorId, domain, sharedContext);
+    }
+    async verifyYoutube(ambassadorId, channelId, sharedContext = {}) {
+        return await this.ambassadorService_.verifyYoutube(ambassadorId, channelId, sharedContext);
+    }
+    // @InjectTransactionManager()
+    // async updatePayoutSettings(
+    //   ambassadorId: string,
+    //   settings: PayoutSettingsDTO,
+    //   @EtoContext() sharedContext: Context = {}
+    // ): Promise<AmbassadorDTO> {
+    //   return await this.ambassadorService_.updatePayoutSettings(
+    //     ambassadorId,
+    //     settings,
+    //     sharedContext
+    //   )
+    // }
+    // ===== PROGRAM METHODS (Delegated to Program Service) =====
+    async createProgram(data, sharedContext = {}) {
+        return await this.programService_.createProgramWithValidation(data, sharedContext);
+    }
+    async getProgramOrThrow(programId, ownerId, ownerType, sharedContext = {}) {
+        return await this.programService_.getProgramOrThrow(programId, ownerId, ownerType, sharedContext);
+    }
+    async listProgramsByOwner(ownerId, ownerType, filters = {}, config = {}, sharedContext = {}) {
+        return await this.programService_.listProgramsByOwner(ownerId, ownerType, filters, config, sharedContext);
+    }
+    async updateProgram(data, sharedContext = {}) {
+        return await this.programService_.updateProgramWithValidation(data, sharedContext);
+    }
+    // ===== ENROLLMENT METHODS (Direct Enrollment) =====
+    async enrollAmbassador(data, sharedContext = {}) {
+        // Get program to check auto-approval
+        const program = await this.programService_.getProgramOrThrow(data.program_id, undefined, undefined, sharedContext);
+        return await this.programEnrollmentService_.enrollAmbassador(data, program.auto_approve_ambassadors, sharedContext);
+    }
+    async approveEnrollment(enrollmentId, sharedContext = {}) {
+        return await this.programEnrollmentService_.updateEnrollmentStatus(enrollmentId, "approved", sharedContext);
+    }
+    async getEnrollmentOrThrow(ambassadorId, programId, sharedContext = {}) {
+        return await this.programEnrollmentService_.getEnrollmentOrThrow(ambassadorId, programId, sharedContext);
+    }
+    async listEnrollmentsByProgram(programId, filters = {}, config = {}, sharedContext = {}) {
+        return await this.programEnrollmentService_.getEnrollmentsByProgram(programId, filters, config, sharedContext);
+    }
+    async calculateEarnings(programId, eventType, amount, sharedContext = {}) {
+        const program = await this.programService_.retrieve(programId, {}, sharedContext);
+        // @ts-ignore
+        const reward = program.rewards?.find((r) => r.event_type === eventType);
+        if (!reward) {
+            return { amount: 0, calculation_type: "no_reward" };
+        }
+        let earnings = 0;
+        if (reward.type === "percentage") {
+            earnings = Math.round((amount * reward.amount) / 100);
+        }
+        else if (reward.type === "flat") {
+            earnings = reward.amount;
+        }
+        return {
+            amount: earnings,
+            calculation_type: reward.type,
+        };
+    }
+    // ===== REWARD MANAGEMENT (Dub Parity) =====
+    // @ts-expect-error
+    async createReward(data, sharedContext = {}) {
+        return await this.rewardService_.create(data, sharedContext);
+    }
+    // @ts-expect-error
+    async listRewards(filters = {}, config = {}, sharedContext = {}) {
+        return await this.rewardService_.list(filters, config, sharedContext);
+    }
+    // @ts-expect-error
+    async retrieveReward(id, config = {}, sharedContext = {}) {
+        return await this.rewardService_.retrieve(id, config, sharedContext);
+    }
+    async updateReward(id, data, sharedContext = {}) {
+        return await this.rewardService_.update({ ...data, id }, sharedContext);
+    }
+    async deleteReward(id, sharedContext = {}) {
+        return await this.rewardService_.delete(id, sharedContext);
+    }
+    // ===== REVENUE RULE MANAGEMENT =====
+    async createRevenueRule(data, sharedContext = {}) {
+        // Validate shares total 100%
+        const total = data.actor_share +
+            data.context_owner_share +
+            data.creator_share +
+            data.beneficiary_share +
+            data.platform_share;
+        if (Math.abs(total - 100) > 0.01) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_ARGUMENT, `Revenue shares must total 100%, got ${total}%`);
+        }
+        // Validate minimum platform share for sustainability
+        if (data.platform_share < 0) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_ARGUMENT, `Platform share cannot be negative, got ${data.platform_share}%`);
+        }
+        return await this.revenueShareRuleService_.create(data, sharedContext);
+    }
+    async listRevenueRules(filters = {}, config = {}, sharedContext = {}) {
+        return await this.revenueShareRuleService_.list(filters, config, sharedContext);
+    }
+    async retrieveRevenueRule(id, config = {}, sharedContext = {}) {
+        return await this.revenueShareRuleService_.retrieve(id, config, sharedContext);
+    }
+    async updateRevenueRule(id, data, sharedContext = {}) {
+        // If updating shares, validate they total 100%
+        if (data.actor_share !== undefined ||
+            data.context_owner_share !== undefined ||
+            data.creator_share !== undefined ||
+            data.beneficiary_share !== undefined ||
+            data.platform_share !== undefined) {
+            // Get current rule to fill in missing values
+            const currentRule = await this.revenueShareRuleService_.retrieve(id, {}, sharedContext);
+            const total = (data.actor_share ?? currentRule.actor_share) +
+                (data.context_owner_share ?? currentRule.context_owner_share) +
+                (data.creator_share ?? currentRule.creator_share) +
+                (data.beneficiary_share ?? currentRule.beneficiary_share) +
+                (data.platform_share ?? currentRule.platform_share);
+            if (Math.abs(total - 100) > 0.01) {
+                throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_ARGUMENT, `Revenue shares must total 100%, got ${total}%`);
+            }
+            const platformShare = data.platform_share ?? currentRule.platform_share;
+            if (platformShare < 0) {
+                throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_ARGUMENT, `Platform share cannot be negative, got ${platformShare}%`);
+            }
+        }
+        return await this.revenueShareRuleService_.update({ ...data, id }, sharedContext);
+    }
+    async deleteRevenueRule(id, sharedContext = {}) {
+        return await this.revenueShareRuleService_.delete(id, sharedContext);
+    }
+    // ===== COMMISSION CALCULATION (Enhanced with Revenue Sharing) =====
+    async calculateCommissionWithRevenueSharing(data, sharedContext = {}) {
+        // 1. Calculate base commission using existing Dub logic
+        const baseResult = await this.calculateCommission({
+            program_id: data.program_id,
+            ambassador_id: data.beneficiary_id, // Use beneficiary for base calculation
+            event_type: data.event_type,
+            amount: data.amount,
+            quantity: data.quantity,
+        }, sharedContext);
+        // 2. Get revenue sharing rules with plan bonus
+        const revenueEvent = {
+            program_id: data.program_id,
+            current_source_type: data.current_source_type,
+            current_source_id: data.current_source_id,
+            original_source_type: data.original_source_type,
+            original_source_id: data.original_source_id,
+            actor_id: data.actor_id,
+            actor_type: data.actor_type,
+            context_owner_id: data.context_owner_id,
+            context_owner_type: data.context_owner_type,
+            creator_id: data.creator_id,
+            creator_type: data.creator_type,
+            beneficiary_id: data.beneficiary_id,
+            beneficiary_type: data.beneficiary_type,
+            beneficiary_plan: data.beneficiary_plan,
+            action: data.event_type === "sale" ? "amplify" : "create",
+            context_type: "community",
+            relationship: "contributor",
+        };
+        const revenueDistribution = await this.revenueRuleResolver_.resolveRevenueRules(revenueEvent, sharedContext);
+        // 3. Apply revenue sharing to base commission
+        const baseCommission = baseResult.total_commission;
+        const actorEarnings = Math.round(baseCommission * (revenueDistribution.actor_share / 100));
+        const beneficiaryEarnings = Math.round(baseCommission * (revenueDistribution.beneficiary_share / 100));
+        const contextOwnerEarnings = Math.round(baseCommission * (revenueDistribution.context_owner_share / 100));
+        const creatorEarnings = Math.round(baseCommission * (revenueDistribution.creator_share / 100));
+        const platformEarnings = Math.round(baseCommission * (revenueDistribution.platform_share / 100));
+        return {
+            base_commission: baseCommission,
+            revenue_distribution: revenueDistribution,
+            actor_earnings: actorEarnings,
+            beneficiary_earnings: beneficiaryEarnings,
+            context_owner_earnings: contextOwnerEarnings,
+            creator_earnings: creatorEarnings,
+            platform_earnings: platformEarnings,
+            total_distributed: actorEarnings +
+                beneficiaryEarnings +
+                contextOwnerEarnings +
+                creatorEarnings +
+                platformEarnings,
+        };
+    }
+    async calculateCommission(data, sharedContext = {}) {
+        // Get enrollment with reward assignments
+        const enrollments = await this.listEnrollmentsByProgram(data.program_id, { ambassador_id: data.ambassador_id, status: "approved" }, {}, sharedContext);
+        if (!enrollments?.length) {
+            return {
+                ambassador_earnings: 0,
+                total_commission: 0,
+            };
+        }
+        const enrollment = enrollments[0];
+        let rewardId;
+        // Get reward based on event type (Dub pattern)
+        switch (data.event_type) {
+            case "click":
+                rewardId = enrollment.click_reward_id;
+                break;
+            case "lead":
+                rewardId = enrollment.lead_reward_id;
+                break;
+            case "sale":
+                rewardId = enrollment.sale_reward_id;
+                break;
+        }
+        if (!rewardId) {
+            return {
+                ambassador_earnings: 0,
+                total_commission: 0,
+            };
+        }
+        // Get reward details
+        const reward = await this.retrieveReward(rewardId, {}, sharedContext);
+        // Calculate base commission (Dub logic)
+        let baseCommission = 0;
+        if (reward.type === "percentage") {
+            baseCommission = Math.round((data.amount || 0) * (reward.amount / 100));
+        }
+        else if (reward.type === "flat") {
+            baseCommission = reward.amount * (data.quantity || 1);
+        }
+        // Apply our revenue sharing scenarios
+        let ambassadorEarnings = baseCommission;
+        let creatorEarnings = 0;
+        let communityEarnings = 0;
+        switch (data.source_type) {
+            case "community":
+                // 70% ambassador, 30% creator
+                ambassadorEarnings = Math.round(baseCommission * 0.7);
+                creatorEarnings = Math.round(baseCommission * 0.3);
+                break;
+            case "repost":
+                // Ambassador gets commission
+                ambassadorEarnings = baseCommission;
+                break;
+            default:
+                // Direct: 100% to ambassador
+                ambassadorEarnings = baseCommission;
+        }
+        // Apply reward limits
+        if (reward.max_amount && ambassadorEarnings > reward.max_amount) {
+            ambassadorEarnings = reward.max_amount;
+        }
+        return {
+            ambassador_earnings: ambassadorEarnings,
+            creator_earnings: creatorEarnings,
+            community_earnings: communityEarnings,
+            total_commission: ambassadorEarnings + creatorEarnings + communityEarnings,
+            reward_used: reward,
+        };
+    }
+    async getAnalyticsTimeseries(params, sharedContext = {}) {
+        const manager = sharedContext.manager;
+        const query = `
+      SELECT
+        TO_CHAR((created_at AT TIME ZONE 'UTC' AT TIME ZONE $1), $2) AS start,
+        COUNT(CASE WHEN event_type = 'click' THEN 1 END)::int AS clicks,
+        COUNT(CASE WHEN event_type = 'lead' THEN 1 END)::int AS leads,
+        COUNT(CASE WHEN event_type = 'sale' THEN 1 END)::int AS sales,
+        COALESCE(SUM(CASE WHEN event_type = 'sale' AND earnings > 0 THEN earnings ELSE 0 END), 0)::int AS "saleAmount",
+        COALESCE(SUM(CASE WHEN event_type = 'sale' AND earnings > 0 THEN earnings ELSE 0 END), 0)::int AS earnings
+      FROM commission
+      WHERE
+        ambassador_id = $3
+        ${params.program_id ? "AND program_id = $4" : ""}
+        AND created_at >= $${params.program_id ? "5" : "4"}::timestamp
+        AND created_at < $${params.program_id ? "6" : "5"}::timestamp
+        AND status IN ('confirmed', 'processed', 'paid')
+      GROUP BY start
+      ORDER BY start ASC
+    `;
+        const queryParams = [
+            params.timezone,
+            params.dateFormat,
+            params.ambassador_id,
+            ...(params.program_id ? [params.program_id] : []),
+            params.start,
+            params.end,
+        ];
+        return (await manager?.execute(query, queryParams)) || [];
+    }
+    async getAnalytics(params, sharedContext = {}) {
+        // Use Dub's date utilities
+        const { startDate, endDate, granularity, dateFormat } = (0, analytics_1.getStartEndDates)({
+            interval: params.interval,
+            start: params.start,
+            end: params.end,
+        });
+        const startStr = startDate.toISOString();
+        const endStr = endDate.toISOString();
+        const timezone = params.timezone || "UTC";
+        // For timeseries, use custom query (Dub pattern)
+        if (params.groupBy === "timeseries") {
+            const timeseries = await this.getAnalyticsTimeseries({
+                ambassador_id: params.ambassador_id,
+                program_id: params.program_id,
+                granularity,
+                dateFormat,
+                start: startStr,
+                end: endStr,
+                timezone,
+            }, sharedContext);
+            // Calculate totals (Dub pattern)
+            const totals = timeseries.reduce((acc, item) => ({
+                clicks: acc.clicks + item.clicks,
+                leads: acc.leads + item.leads,
+                sales: acc.sales + item.sales,
+                saleAmount: acc.saleAmount + item.saleAmount,
+            }), { clicks: 0, leads: 0, sales: 0, saleAmount: 0 });
+            return { ...totals, earnings: totals.saleAmount, timeseries };
+        }
+        // For count, use aggregate query (Dub pattern)
+        const manager = sharedContext.manager;
+        const countQuery = `
+      SELECT
+        COUNT(CASE WHEN event_type = 'click' THEN 1 END)::int AS clicks,
+        COUNT(CASE WHEN event_type = 'lead' THEN 1 END)::int AS leads,
+        COUNT(CASE WHEN event_type = 'sale' THEN 1 END)::int AS sales,
+        COALESCE(SUM(CASE WHEN event_type = 'sale' AND earnings > 0 THEN earnings ELSE 0 END), 0)::int AS "saleAmount"
+      FROM commission
+      WHERE
+        ambassador_id = $1
+        ${params.program_id ? "AND program_id = $2" : ""}
+        AND created_at >= $${params.program_id ? "3" : "2"}::timestamp
+        AND created_at < $${params.program_id ? "4" : "3"}::timestamp
+        AND status IN ('confirmed', 'processed', 'paid')
+    `;
+        const countParams = [
+            params.ambassador_id,
+            ...(params.program_id ? [params.program_id] : []),
+            startStr,
+            endStr,
+        ];
+        const [result] = (await manager?.execute(countQuery, countParams)) || [
+            { clicks: 0, leads: 0, sales: 0, saleAmount: 0 },
+        ];
+        // todo fix
+        // @ts-ignore
+        return { ...result, earnings: result.saleAmount };
+    }
+    async findProgramsByResource(params, sharedContext = {}) {
+        const manager = sharedContext.manager;
+        // Query to determine program access based on ownership and settings
+        const query = `
+      SELECT 
+        p.*,
+        pe.status as enrollment_status,
+        CASE 
+          WHEN p.auto_approve_ambassadors = true THEN 'public'
+          ELSE 'private'
+        END as access_type,
+        CASE 
+          WHEN p.owner_id = (
+            SELECT owner_id FROM ${params.resource_type} 
+            WHERE id = $3
+          ) THEN true
+          ELSE false
+        END as is_owner_match,
+        CASE 
+          WHEN pe.status = 'approved' THEN true
+          WHEN p.auto_approve_ambassadors = true THEN true
+          WHEN p.owner_id = (
+            SELECT owner_id FROM ${params.resource_type} 
+            WHERE id = $3
+          ) THEN true
+          ELSE false
+        END as can_activate
+      FROM program p
+      LEFT JOIN program_enrollment pe ON (
+        pe.program_id = p.id 
+        AND pe.ambassador_id = $1
+        AND pe.status IN ('approved', 'pending')
+      )
+      WHERE 
+        p.status = $2
+        ${params.category ? "AND p.category = $4" : ""}
+        ${params.access_type
+            ? `AND (
+          CASE 
+            WHEN p.auto_approve_ambassadors = true THEN 'public'
+            ELSE 'private'
+          END = $${params.category ? "5" : "4"}
+        )`
+            : ""}
+      ORDER BY p.created_at DESC
+    `;
+        const queryParams = [
+            params.ambassador_id || null,
+            params.status || "active",
+            params.resource_id,
+            ...(params.category ? [params.category] : []),
+            ...(params.access_type ? [params.access_type] : []),
+        ];
+        const results = (await manager?.execute(query, queryParams)) || [];
+        // The 'program' field must fulfill the ProgramDTO type.
+        // Return all properties defined in ProgramDTO, even if null/undefined if not present in row.
+        // @ts-ignore
+        return results.map((row) => ({
+            program: {
+                id: row.id,
+                owner_id: row.owner_id,
+                owner_type: row.owner_type,
+                name: row.name,
+                slug: row.slug,
+                description: row.description,
+                category: row.category,
+                commission_type: row.commission_type,
+                commission_rate: row.commission_rate,
+                commission_currency: row.commission_currency,
+                commission_min_payout: row.commission_min_payout,
+                commission_summary: row.commission_summary,
+                auto_approve_ambassadors: row.auto_approve_ambassadors,
+                max_ambassador_links: row.max_ambassador_links,
+                is_active: row.is_active,
+                status: row.status,
+                created_at: row.created_at,
+                updated_at: row.updated_at,
+                deleted_at: row.deleted_at,
+            },
+            enrollment_status: row.enrollment_status,
+            can_activate: row.can_activate,
+            access_type: row.access_type,
+            is_owner_match: row.is_owner_match,
+        }));
+    }
+    // ===== ENROLLMENT MANAGEMENT =====
+    async createEnrollment(data, sharedContext = {}) {
+        return await this.programEnrollmentService_.create({
+            program_id: data.program_id,
+            ambassador_id: data.ambassador_id,
+            application_message: data.application_message,
+            status: data.status || "pending",
+            source: data.source || "application",
+            invited_by: data.invited_by,
+            metadata: data.metadata,
+        }, sharedContext);
+    }
+    async updateProgramEnrollment(id, data, sharedContext = {}) {
+        return await this.programEnrollmentService_.update({ ...data, id }, sharedContext);
+    }
+    async retrieveEnrollment(id, sharedContext = {}) {
+        return await this.programEnrollmentService_.retrieve(id, {}, sharedContext);
+    }
+    async updateEnrollment(id, data, sharedContext = {}) {
+        data.id = id;
+        return await this.programEnrollmentService_.update(data, sharedContext);
+    }
+    async deleteEnrollments(ids, sharedContext = {}) {
+        await this.programEnrollmentService_.delete(ids, sharedContext);
+    }
+    // ===== WORKFLOW-LEVEL OPERATIONS (Cross-Module Dependencies) =====
+    // These operations require workflow orchestration due to external module dependencies:
+    // 🔄 createAmbassadorWithLink() → Needs Link Module (create-partner-link.ts)
+    // 🔄 createAndEnrollAmbassador() → Needs Link + Group Modules (create-and-enroll-partner.ts)
+    // 🔄 notifyCommissionCreated() → Needs Email/Notification Module (notify-partner-commission.ts)
+    // 🔄 backfillCommissions() → Needs Analytics/Tinybird Module (backfill-link-commissions.ts)
+    // 🔄 bulkDeleteAmbassadors() → Needs Link Module cleanup (bulk-delete-partners.ts)
+    // ===== COMMISSION METHODS (Atomic Operations for API) =====
+    async createCommission(data, sharedContext = {}) {
+        return await this.commissionService_.createCommission(data, sharedContext);
+    }
+    /**
+     * Updates an array of commissions by ID with provided fields.
+     *
+     * @param ids string[] - list of commission IDs
+     * @param data Partial<CommissionDTO> - fields to update for all IDs
+     * @returns Promise<CommissionDTO[]>
+     *
+     * Example: updateCommissions(["comm_123", "comm_456"], { payout_id: "payout_123" })
+     */
+    // @ts-expect-error
+    async updateCommissions(ids, data, sharedContext = {}) {
+        // Transform ids into the expected bulk update shape for service
+        const payload = ids.map(id => ({
+            ...data,
+            id,
+        }));
+        return await this.commissionService_.update(payload, sharedContext);
+    }
+    // @ts-expect-error
+    async createCommissions(data, sharedContext = {}) {
+        return await this.commissionService_.create(data, sharedContext);
+    }
+    // @ts-expect-error
+    async listCommissions(filters = {}, config = {}, sharedContext = {}) {
+        return await this.commissionService_.getCommissionsByFilters(filters, config, sharedContext);
+    }
+    async updateCommissionStatus(commissionId, status, sharedContext = {}) {
+        return await this.commissionService_.updateCommissionStatus(commissionId, status, sharedContext);
+    }
+    // ===== PERFORMANCE ANALYTICS (Module-Level Composition) =====
+    async getAmbassadorPerformance(ambassadorId, filters = {}, sharedContext = {}) {
+        const commissions = await this.commissionService_.getCommissionsByFilters({
+            ambassador_id: ambassadorId,
+            ...filters,
+        }, {}, sharedContext);
+        const totalEarnings = commissions.reduce((sum, c) => sum + c.earnings, 0);
+        const clickCount = commissions.filter((c) => c.type === "click").length;
+        const saleCount = commissions.filter((c) => c.type === "sale").length;
+        const conversionRate = clickCount > 0 ? (saleCount / clickCount) * 100 : 0;
+        return {
+            total_commissions: commissions.length,
+            total_earnings: totalEarnings,
+            click_count: clickCount,
+            sale_count: saleCount,
+            conversion_rate: Math.round(conversionRate * 100) / 100,
+        };
+    }
+    async getPayoutEligibleCommissions(programId, ambassadorId, sharedContext = {}) {
+        // Get program to determine holding period
+        const program = await this.programService_.getProgramOrThrow(programId, undefined, undefined, sharedContext);
+        // Calculate cutoff date
+        const cutoffDate = program.holding_period_days > 0
+            ? new Date(Date.now() - program.holding_period_days * 24 * 60 * 60 * 1000)
+            : new Date(0);
+        // Get eligible commissions and clawbacks
+        const { eligible, clawbacks } = await this.commissionService_.getCommissionsForPayout(programId, ambassadorId, cutoffDate, sharedContext);
+        return {
+            eligible,
+            clawbacks,
+            holdingPeriodDays: program.holding_period_days,
+        };
+    }
+    // ===== REWARD METHODS (Atomic Operations for API) =====
+    // @ts-expect-error
+    async createReward(data, sharedContext = {}) {
+        return await this.rewardService_.createReward(data, sharedContext);
+    }
+    async listRewardsByProgram(programId, filters = {}, config = {}, sharedContext = {}) {
+        return await this.rewardService_.getRewardsByProgram(programId, filters, config, sharedContext);
+    }
+    // ===== PAYOUT METHODS (Atomic Operations for API) =====
+    async createPayout(data, sharedContext = {}) {
+        return await this.payoutService_.createPayout(data, sharedContext);
+    }
+    async listPayoutsByProgram(programId, filters = {}, config = {}, sharedContext = {}) {
+        return await this.payoutService_.getPayoutsByProgram(programId, filters, config, sharedContext);
+    }
+    async getEligiblePayouts(programId, cutoffDate, sharedContext = {}) {
+        // Get program to determine min payout amount
+        const program = await this.programService_.getProgramOrThrow(programId, undefined, undefined, sharedContext);
+        return await this.payoutService_.getEligiblePayouts(programId, program.min_payout_amount, cutoffDate, sharedContext);
+    }
+    async updatePayoutStatus(payoutId, status, sharedContext = {}) {
+        return await this.payoutService_.updatePayoutStatus(payoutId, status, sharedContext);
+    }
+    // ===== COMMISSION TRACKING =====
+    async recordCommission(data, sharedContext = {}) {
+        // TODO: Calculate earnings based on reward rules
+        const commission = await this.commissionService_.create([
+            {
+                id: (0, utils_1.generateEntityId)("", "com"),
+                ...data,
+                earnings: data.earnings || 0,
+                currency: "usd",
+                status: "pending",
+            },
+        ], sharedContext);
+        return commission[0];
+    }
+}
+exports.default = AmbassadorModuleService;
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(3, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "createAmbassador", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "getAmbassadorBySource", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-expect-error
+    ,
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "listAmbassadors", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "verifyWebsite", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "verifyYoutube", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "createProgram", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(3, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "getProgramOrThrow", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(4, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "listProgramsByOwner", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "updateProgram", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "enrollAmbassador", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "approveEnrollment", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "getEnrollmentOrThrow", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(3, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "listEnrollmentsByProgram", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(3, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Number, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "calculateEarnings", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)()
+    // @ts-expect-error
+    ,
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "createReward", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-expect-error
+    ,
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "listRewards", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-expect-error
+    ,
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "retrieveReward", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "updateReward", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "deleteReward", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "createRevenueRule", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "listRevenueRules", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "retrieveRevenueRule", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "updateRevenueRule", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "deleteRevenueRule", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "calculateCommissionWithRevenueSharing", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "calculateCommission", null);
+__decorate([
+    (0, utils_1.InjectManager)("AmbassadorRepository_"),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "getAnalyticsTimeseries", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "getAnalytics", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "findProgramsByResource", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "createEnrollment", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "updateProgramEnrollment", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "retrieveEnrollment", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "updateEnrollment", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "deleteEnrollments", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "createCommission", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)()
+    // @ts-expect-error
+    ,
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "updateCommissions", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)()
+    // @ts-expect-error
+    ,
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "createCommissions", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-expect-error
+    ,
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "listCommissions", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "updateCommissionStatus", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "getAmbassadorPerformance", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "getPayoutEligibleCommissions", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)()
+    // @ts-expect-error
+    ,
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "createReward", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(3, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "listRewardsByProgram", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "createPayout", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(3, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "listPayoutsByProgram", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Date, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "getEligiblePayouts", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "updatePayoutStatus", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AmbassadorModuleService.prototype, "recordCommission", null);
+//# sourceMappingURL=ambassador-module-service.js.map