@classytic/promo 0.1.0 → 0.2.1

package/dist/services-Cz0gHrmX.mjs

@@ -1,815 +0,0 @@
-import { o as PROGRAM_TRANSITIONS } from "./constants-BVajdyL3.mjs";
-import { a as ProgramNotFoundError, c as TenantIsolationError, d as VoucherExpiredError, f as VoucherNotFoundError, i as InvalidTransitionError, l as ValidationError, n as EvaluationNotFoundError, r as InsufficientBalanceError, t as DuplicateRedemptionError, u as VoucherExhaustedError } from "./domain-errors-BEkXvy5O.mjs";
-import { t as PromoEvents } from "./event-types-CsTV1FKX.mjs";
-import { randomBytes } from "node:crypto";
-//#region src/utils/tenant-guard.ts
-function assertTenantContext(ctx, tenant) {
-	if (!tenant.enabled) return;
-	if (!ctx[tenant.contextKey]) throw new TenantIsolationError();
-}
-function getTenantValue(ctx, tenant) {
-	if (!tenant.enabled) return void 0;
-	return ctx[tenant.contextKey];
-}
-//#endregion
-//#region src/services/evaluation.service.ts
-var EvaluationService = class {
-	pendingEvaluations = /* @__PURE__ */ new Map();
-	constructor(programPort, rulePort, rewardPort, voucherPort, unitOfWork, events, config) {
-		this.programPort = programPort;
-		this.rulePort = rulePort;
-		this.rewardPort = rewardPort;
-		this.voucherPort = voucherPort;
-		this.unitOfWork = unitOfWork;
-		this.events = events;
-		this.config = config;
-	}
-	async evaluate(input, ctx) {
-		return this.doEvaluate(input, ctx, false);
-	}
-	async preview(input, ctx) {
-		return this.doEvaluate(input, ctx, true);
-	}
-	async commit(evaluationId, orderId, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const stored = this.pendingEvaluations.get(evaluationId);
-		if (!stored) throw new EvaluationNotFoundError(evaluationId);
-		return this.unitOfWork.withTransaction(async (session) => {
-			for (const usage of stored.programUsages) {
-				await this.programPort.incrementUsage(usage.programId, tenantId, session);
-				if (stored.customerId) await this.programPort.incrementCustomerUsage(usage.programId, stored.customerId, tenantId, session);
-			}
-			for (const usage of stored.voucherUsages) await this.voucherPort.incrementUsage(usage.voucherId, {
-				orderId,
-				discountAmount: usage.discountAmount,
-				redeemedAt: /* @__PURE__ */ new Date()
-			}, tenantId, session);
-			this.pendingEvaluations.delete(evaluationId);
-			const commitResult = {
-				evaluationId,
-				orderId,
-				totalDiscount: stored.result.totalDiscount,
-				programsCommitted: stored.programUsages.length,
-				vouchersUsed: stored.voucherUsages.length
-			};
-			this.events.emit(PromoEvents.EVALUATION_COMMITTED, {
-				evaluationId,
-				orderId,
-				totalDiscount: stored.result.totalDiscount
-			});
-			return commitResult;
-		});
-	}
-	async rollback(evaluationId, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		if (!this.pendingEvaluations.get(evaluationId)) return;
-		this.pendingEvaluations.delete(evaluationId);
-		this.events.emit(PromoEvents.EVALUATION_ROLLED_BACK, { evaluationId });
-	}
-	async doEvaluate(input, ctx, isPreview) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const submittedCodes = (input.codes ?? []).map((c) => c.toUpperCase());
-		const programs = await this.programPort.findActive(tenantId);
-		const programIds = programs.map((p) => p._id);
-		const [allRules, allRewards] = await Promise.all([this.rulePort.findByProgramIds(programIds, tenantId), this.rewardPort.findByProgramIds(programIds, tenantId)]);
-		const rulesByProgram = groupBy(allRules, (r) => r.programId);
-		const rewardsByProgram = groupBy(allRewards, (r) => r.programId);
-		const voucherMap = /* @__PURE__ */ new Map();
-		for (const code of submittedCodes) {
-			const voucher = await this.voucherPort.getByCode(code, tenantId);
-			if (voucher && voucher.status === "active" && voucher.usedCount < voucher.usageLimit) voucherMap.set(code, {
-				voucherId: voucher._id,
-				programId: voucher.programId,
-				balance: voucher.currentBalance
-			});
-		}
-		const appliedDiscounts = [];
-		const freeProducts = [];
-		const appliedCodes = [];
-		const rejectedCodes = [];
-		const warnings = [];
-		const programsApplied = [];
-		const programUsages = [];
-		const voucherUsages = [];
-		let runningSubtotal = input.subtotal;
-		let exclusiveApplied = false;
-		let stackableCount = 0;
-		for (const program of programs) {
-			if (program.maxUsageTotal && program.usedCount >= program.maxUsageTotal) continue;
-			if (!this.isCustomerEligible(program, input)) continue;
-			if (program.maxUsagePerCustomer && input.customerId) {
-				if (await this.programPort.getCustomerUsage(program._id, input.customerId, tenantId) >= program.maxUsagePerCustomer) {
-					warnings.push(`Customer has reached max usage (${program.maxUsagePerCustomer}) for "${program.name}"`);
-					continue;
-				}
-			}
-			if (program.stackingMode === "exclusive" && exclusiveApplied) continue;
-			if (program.stackingMode === "stackable" && stackableCount >= this.config.evaluation.maxStackablePromotions) {
-				warnings.push(`Max stackable promotions (${this.config.evaluation.maxStackablePromotions}) reached`);
-				continue;
-			}
-			const rules = rulesByProgram.get(String(program._id)) ?? [];
-			const rewards = rewardsByProgram.get(String(program._id)) ?? [];
-			if (rules.length === 0 || rewards.length === 0) continue;
-			const matchResult = this.matchBestRule(program, rules, input.items, input.subtotal, submittedCodes, voucherMap);
-			if (!matchResult.matched) {
-				if (matchResult.rejectedCode) rejectedCodes.push(matchResult.rejectedCode);
-				continue;
-			}
-			const applicableRewards = this.filterRewardsByRule(rewards, matchResult.matchedRuleId);
-			for (const reward of applicableRewards) if (reward.rewardType === "discount") {
-				const discount = this.computeDiscount(reward, input.items, runningSubtotal);
-				if (discount <= 0) continue;
-				appliedDiscounts.push({
-					programId: program._id,
-					programName: program.name,
-					rewardId: reward._id,
-					type: reward.discountMode ?? "fixed",
-					scope: reward.discountScope,
-					amount: discount,
-					description: this.describeDiscount(reward, program),
-					voucherCode: matchResult.matchedCode
-				});
-				runningSubtotal = Math.max(0, runningSubtotal - discount);
-			} else if (reward.rewardType === "free_product") freeProducts.push({
-				programId: program._id,
-				programName: program.name,
-				rewardId: reward._id,
-				productId: reward.freeProductId,
-				productSku: reward.freeProductSku,
-				quantity: reward.freeQuantity,
-				description: `Free product from "${program.name}"`
-			});
-			programsApplied.push(program._id);
-			programUsages.push({ programId: program._id });
-			if (matchResult.matchedCode) {
-				appliedCodes.push(matchResult.matchedCode);
-				const voucherInfo = voucherMap.get(matchResult.matchedCode);
-				if (voucherInfo) {
-					const totalProgramDiscount = appliedDiscounts.filter((d) => d.programId === program._id).reduce((sum, d) => sum + d.amount, 0);
-					voucherUsages.push({
-						voucherId: voucherInfo.voucherId,
-						code: matchResult.matchedCode,
-						discountAmount: totalProgramDiscount
-					});
-				}
-			}
-			if (program.stackingMode === "exclusive") exclusiveApplied = true;
-			else stackableCount++;
-		}
-		for (const code of submittedCodes) if (!appliedCodes.includes(code) && !rejectedCodes.some((r) => r.code === code)) rejectedCodes.push({
-			code,
-			reason: "No matching active program found for this code"
-		});
-		const totalDiscount = appliedDiscounts.reduce((sum, d) => sum + d.amount, 0);
-		const evaluationId = randomBytes(16).toString("hex");
-		const result = {
-			evaluationId,
-			appliedDiscounts,
-			freeProducts,
-			totalDiscount,
-			subtotalAfterDiscount: Math.max(0, input.subtotal - totalDiscount),
-			appliedCodes,
-			rejectedCodes,
-			warnings,
-			isPreview,
-			programsApplied
-		};
-		if (!isPreview) this.pendingEvaluations.set(evaluationId, {
-			result,
-			tenantId,
-			customerId: input.customerId,
-			programUsages,
-			voucherUsages,
-			createdAt: Date.now()
-		});
-		this.events.emit(PromoEvents.EVALUATION_COMPLETED, {
-			evaluationId,
-			totalDiscount,
-			programsApplied: programsApplied.length,
-			codesUsed: appliedCodes,
-			isPreview
-		});
-		return result;
-	}
-	isCustomerEligible(program, input) {
-		if (program.applicableCustomerIds.length > 0) {
-			if (!input.customerId) return false;
-			if (!program.applicableCustomerIds.includes(input.customerId)) return false;
-		}
-		if (program.applicableCustomerTags.length > 0) {
-			const customerTags = input.customerTags ?? [];
-			if (customerTags.length === 0) return false;
-			if (!program.applicableCustomerTags.some((tag) => customerTags.includes(tag))) return false;
-		}
-		return true;
-	}
-	matchBestRule(program, rules, items, subtotal, submittedCodes, voucherMap) {
-		let bestMatch = { matched: false };
-		let bestThreshold = -1;
-		let lastRejected;
-		for (const rule of rules) {
-			const singleResult = this.matchSingleRule(program, rule, items, subtotal, submittedCodes, voucherMap);
-			if (singleResult.rejectedCode) lastRejected = singleResult.rejectedCode;
-			if (!singleResult.matched) continue;
-			const threshold = (rule.minimumAmount ?? 0) * 1e3 + (rule.minimumQuantity ?? 0);
-			if (threshold > bestThreshold) {
-				bestThreshold = threshold;
-				bestMatch = singleResult;
-			}
-		}
-		if (!bestMatch.matched && lastRejected) bestMatch.rejectedCode = lastRejected;
-		return bestMatch;
-	}
-	matchSingleRule(program, rule, items, subtotal, submittedCodes, voucherMap) {
-		if (program.triggerMode === "code") {
-			if (rule.code) {
-				if (!submittedCodes.includes(rule.code)) return { matched: false };
-				if (program.programType === "coupon" || program.programType === "discount_code") {
-					const voucherInfo = voucherMap.get(rule.code);
-					if (!voucherInfo || String(voucherInfo.programId) !== String(program._id)) return {
-						matched: false,
-						rejectedCode: {
-							code: rule.code,
-							reason: "Invalid or exhausted voucher"
-						}
-					};
-				}
-			} else if (![...voucherMap.entries()].find(([code, info]) => String(info.programId) === String(program._id) && submittedCodes.includes(code))) return { matched: false };
-		}
-		const now = /* @__PURE__ */ new Date();
-		if (rule.startsAt && rule.startsAt > now) return { matched: false };
-		if (rule.endsAt && rule.endsAt < now) return { matched: false };
-		if (rule.minimumAmount > 0 && subtotal < rule.minimumAmount) return { matched: false };
-		if (rule.minimumQuantity > 0) {
-			if (items.reduce((sum, item) => sum + item.quantity, 0) < rule.minimumQuantity) return { matched: false };
-		}
-		if (rule.applicableProductIds.length > 0) {
-			if (!items.some((item) => rule.applicableProductIds.includes(item.productId))) return { matched: false };
-		}
-		if (rule.applicableCategories.length > 0) {
-			if (!items.some((item) => item.categoryId && rule.applicableCategories.includes(item.categoryId))) return { matched: false };
-		}
-		if (rule.applicableSkus.length > 0) {
-			if (!items.some((item) => item.sku && rule.applicableSkus.includes(item.sku))) return { matched: false };
-		}
-		if (rule.buyQuantity && rule.buyQuantity > 0) {
-			if (items.filter((item) => rule.applicableProductIds.length === 0 || rule.applicableProductIds.includes(item.productId)).reduce((sum, item) => sum + item.quantity, 0) < rule.buyQuantity) return { matched: false };
-		}
-		let matchedCode;
-		if (program.triggerMode === "code") if (rule.code && submittedCodes.includes(rule.code)) matchedCode = rule.code;
-		else matchedCode = [...voucherMap.entries()].find(([code, info]) => String(info.programId) === String(program._id) && submittedCodes.includes(code))?.[0];
-		return {
-			matched: true,
-			matchedCode,
-			matchedRuleId: rule._id
-		};
-	}
-	filterRewardsByRule(rewards, matchedRuleId) {
-		if (!matchedRuleId) return rewards;
-		if (rewards.filter((r) => r.ruleId).length === 0) return rewards;
-		return rewards.filter((r) => !r.ruleId || String(r.ruleId) === String(matchedRuleId));
-	}
-	computeDiscount(reward, items, runningSubtotal) {
-		if (!reward.discountAmount || reward.discountAmount <= 0) return 0;
-		let discount;
-		if (reward.discountScope === "cheapest") {
-			const eligibleItems = this.getEligibleItems(reward, items);
-			if (eligibleItems.length === 0) return 0;
-			const cheapest = Math.min(...eligibleItems.map((item) => item.unitPrice));
-			discount = reward.discountMode === "percentage" ? cheapest * (reward.discountAmount / 100) : Math.min(reward.discountAmount, cheapest);
-		} else if (reward.discountScope === "specific_products") {
-			const eligibleTotal = this.getEligibleItems(reward, items).reduce((sum, item) => sum + (item.lineTotal ?? item.unitPrice * item.quantity), 0);
-			if (eligibleTotal <= 0) return 0;
-			discount = reward.discountMode === "percentage" ? eligibleTotal * (reward.discountAmount / 100) : Math.min(reward.discountAmount, eligibleTotal);
-		} else discount = reward.discountMode === "percentage" ? runningSubtotal * (reward.discountAmount / 100) : Math.min(reward.discountAmount, runningSubtotal);
-		if (reward.maxDiscountAmount && discount > reward.maxDiscountAmount) discount = reward.maxDiscountAmount;
-		return Math.min(Math.round(discount * 100) / 100, runningSubtotal);
-	}
-	getEligibleItems(reward, items) {
-		if (reward.applicableProductIds.length === 0) return items;
-		return items.filter((item) => reward.applicableProductIds.includes(item.productId));
-	}
-	describeDiscount(reward, program) {
-		if (reward.discountMode === "percentage") return `${reward.discountAmount}% off from "${program.name}"`;
-		return `${reward.discountAmount} off from "${program.name}"`;
-	}
-};
-function groupBy(items, keyFn) {
-	const map = /* @__PURE__ */ new Map();
-	for (const item of items) {
-		const key = String(keyFn(item));
-		const group = map.get(key);
-		if (group) group.push(item);
-		else map.set(key, [item]);
-	}
-	return map;
-}
-//#endregion
-//#region src/services/program.service.ts
-var ProgramService = class {
-	constructor(programPort, rulePort, rewardPort, events, config) {
-		this.programPort = programPort;
-		this.rulePort = rulePort;
-		this.rewardPort = rewardPort;
-		this.events = events;
-		this.config = config;
-	}
-	async create(input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const data = {
-			...input,
-			status: "draft",
-			usedCount: 0,
-			...tenantId ? { [this.config.tenant.field]: tenantId } : {}
-		};
-		const program = await this.programPort.create(data);
-		this.events.emit(PromoEvents.PROGRAM_CREATED, {
-			programId: program._id,
-			programType: program.programType,
-			status: program.status,
-			actorId: ctx.actorId
-		});
-		return program;
-	}
-	async getById(id, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const program = await this.programPort.getById(id, getTenantValue(ctx, this.config.tenant));
-		if (!program) throw new ProgramNotFoundError(id);
-		return program;
-	}
-	async list(query, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const filters = {
-			...query.filters,
-			...tenantId ? { [this.config.tenant.field]: tenantId } : {}
-		};
-		const programs = await this.programPort.findMany(filters, {
-			limit: query.limit ?? 20,
-			page: query.page ?? 1,
-			sort: query.sort ?? "-priority"
-		});
-		return {
-			docs: programs,
-			page: query.page ?? 1,
-			limit: query.limit ?? 20,
-			total: programs.length,
-			pages: 1,
-			hasNext: false,
-			hasPrev: false
-		};
-	}
-	async update(id, input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		if (!await this.programPort.getById(id, tenantId)) throw new ProgramNotFoundError(id);
-		return this.programPort.update(id, input, tenantId);
-	}
-	async activate(id, ctx) {
-		return this.transition(id, "active", ctx);
-	}
-	async pause(id, ctx) {
-		return this.transition(id, "paused", ctx);
-	}
-	async archive(id, ctx) {
-		return this.transition(id, "archived", ctx);
-	}
-	async transition(id, targetStatus, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const program = await this.programPort.getById(id, tenantId);
-		if (!program) throw new ProgramNotFoundError(id);
-		if (!PROGRAM_TRANSITIONS[program.status]?.includes(targetStatus)) throw new InvalidTransitionError(program.status, targetStatus);
-		const updated = await this.programPort.update(id, { status: targetStatus }, tenantId);
-		const eventMap = {
-			active: PromoEvents.PROGRAM_ACTIVATED,
-			paused: PromoEvents.PROGRAM_PAUSED,
-			archived: PromoEvents.PROGRAM_ARCHIVED
-		};
-		if (eventMap[targetStatus]) this.events.emit(eventMap[targetStatus], {
-			programId: updated._id,
-			programType: updated.programType,
-			status: updated.status,
-			actorId: ctx.actorId
-		});
-		return updated;
-	}
-	async addRule(programId, input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const program = await this.programPort.getById(programId, tenantId);
-		if (!program) throw new ProgramNotFoundError(programId);
-		if (input.code && program.triggerMode !== "code") throw new ValidationError("Cannot add a code-based rule to an auto-triggered program");
-		const data = {
-			...input,
-			programId,
-			...tenantId ? { [this.config.tenant.field]: tenantId } : {}
-		};
-		const rule = await this.rulePort.create(data);
-		this.events.emit(PromoEvents.RULE_ADDED, {
-			programId,
-			ruleId: rule._id,
-			actorId: ctx.actorId
-		});
-		return rule;
-	}
-	async updateRule(programId, ruleId, input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const rule = await this.rulePort.getById(ruleId, tenantId);
-		if (!rule || String(rule.programId) !== String(programId)) throw new ValidationError("Rule not found in this program");
-		const updated = await this.rulePort.update(ruleId, input, tenantId);
-		this.events.emit(PromoEvents.RULE_UPDATED, {
-			programId,
-			ruleId,
-			actorId: ctx.actorId
-		});
-		return updated;
-	}
-	async removeRule(programId, ruleId, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const rule = await this.rulePort.getById(ruleId, tenantId);
-		if (!rule || String(rule.programId) !== String(programId)) throw new ValidationError("Rule not found in this program");
-		await this.rulePort.delete(ruleId, tenantId);
-		this.events.emit(PromoEvents.RULE_REMOVED, {
-			programId,
-			ruleId,
-			actorId: ctx.actorId
-		});
-	}
-	async listRules(programId, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		return this.rulePort.findByProgramId(programId, getTenantValue(ctx, this.config.tenant));
-	}
-	async addReward(programId, input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		if (!await this.programPort.getById(programId, tenantId)) throw new ProgramNotFoundError(programId);
-		const data = {
-			...input,
-			programId,
-			...tenantId ? { [this.config.tenant.field]: tenantId } : {}
-		};
-		const reward = await this.rewardPort.create(data);
-		this.events.emit(PromoEvents.REWARD_ADDED, {
-			programId,
-			rewardId: reward._id,
-			actorId: ctx.actorId
-		});
-		return reward;
-	}
-	async updateReward(programId, rewardId, input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const reward = await this.rewardPort.getById(rewardId, tenantId);
-		if (!reward || String(reward.programId) !== String(programId)) throw new ValidationError("Reward not found in this program");
-		const updated = await this.rewardPort.update(rewardId, input, tenantId);
-		this.events.emit(PromoEvents.REWARD_UPDATED, {
-			programId,
-			rewardId,
-			actorId: ctx.actorId
-		});
-		return updated;
-	}
-	async removeReward(programId, rewardId, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const reward = await this.rewardPort.getById(rewardId, tenantId);
-		if (!reward || String(reward.programId) !== String(programId)) throw new ValidationError("Reward not found in this program");
-		await this.rewardPort.delete(rewardId, tenantId);
-		this.events.emit(PromoEvents.REWARD_REMOVED, {
-			programId,
-			rewardId,
-			actorId: ctx.actorId
-		});
-	}
-	async listRewards(programId, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		return this.rewardPort.findByProgramId(programId, getTenantValue(ctx, this.config.tenant));
-	}
-	async getFullProgram(id, ctx) {
-		const program = await this.getById(id, ctx);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const [rules, rewards] = await Promise.all([this.rulePort.findByProgramId(id, tenantId), this.rewardPort.findByProgramId(id, tenantId)]);
-		return {
-			...program,
-			rules,
-			rewards
-		};
-	}
-};
-//#endregion
-//#region src/utils/code-generator.ts
-const CHARSET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-function generateCode(length, prefix = "") {
-	const bytes = randomBytes(length);
-	let code = "";
-	for (let i = 0; i < length; i++) code += CHARSET[bytes[i] % 32];
-	return prefix ? `${prefix}${code}` : code;
-}
-function generateCodes(count, length, prefix = "") {
-	const codes = /* @__PURE__ */ new Set();
-	let attempts = 0;
-	const maxAttempts = count * 10;
-	while (codes.size < count && attempts < maxAttempts) {
-		codes.add(generateCode(length, prefix));
-		attempts++;
-	}
-	return [...codes];
-}
-//#endregion
-//#region src/services/voucher.service.ts
-var VoucherService = class {
-	constructor(voucherPort, programPort, unitOfWork, events, config) {
-		this.voucherPort = voucherPort;
-		this.programPort = programPort;
-		this.unitOfWork = unitOfWork;
-		this.events = events;
-		this.config = config;
-	}
-	async generateCodes(input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const program = await this.programPort.getById(input.programId, tenantId);
-		if (!program) throw new ProgramNotFoundError(input.programId);
-		const { codeLength, codePrefix } = this.config.voucher;
-		const codes = generateCodes(input.count, codeLength, codePrefix);
-		const expiresAt = input.expiresAt ?? (this.config.voucher.defaultExpiryDays ? new Date(Date.now() + this.config.voucher.defaultExpiryDays * 864e5) : void 0);
-		const isGiftCard = program.programType === "gift_card";
-		const balance = isGiftCard ? 0 : 0;
-		const data = codes.map((code) => ({
-			programId: input.programId,
-			code,
-			status: "active",
-			customerId: input.customerId,
-			usageLimit: isGiftCard ? 999999 : 1,
-			usedCount: 0,
-			...isGiftCard ? {
-				initialBalance: balance,
-				currentBalance: balance,
-				balanceLedger: []
-			} : {},
-			...expiresAt ? { expiresAt } : {},
-			redemptions: [],
-			...input.metadata ? { metadata: input.metadata } : {},
-			...tenantId ? { [this.config.tenant.field]: tenantId } : {}
-		}));
-		const vouchers = await this.voucherPort.createMany(data);
-		this.events.emit(PromoEvents.VOUCHER_GENERATED, {
-			programId: input.programId,
-			voucherIds: vouchers.map((v) => v._id),
-			codes: vouchers.map((v) => v.code),
-			count: vouchers.length,
-			actorId: ctx.actorId
-		});
-		return vouchers;
-	}
-	async generateSingleCode(input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const program = await this.programPort.getById(input.programId, tenantId);
-		if (!program) throw new ProgramNotFoundError(input.programId);
-		const code = input.code?.toUpperCase() ?? generateCode(this.config.voucher.codeLength, this.config.voucher.codePrefix);
-		const isGiftCard = program.programType === "gift_card";
-		const balance = input.initialBalance ?? 0;
-		const expiresAt = input.expiresAt ?? (this.config.voucher.defaultExpiryDays ? new Date(Date.now() + this.config.voucher.defaultExpiryDays * 864e5) : void 0);
-		const data = {
-			programId: input.programId,
-			code,
-			status: "active",
-			customerId: input.customerId,
-			usageLimit: isGiftCard ? 999999 : 1,
-			usedCount: 0,
-			...isGiftCard ? {
-				initialBalance: balance,
-				currentBalance: balance,
-				balanceLedger: []
-			} : {},
-			...expiresAt ? { expiresAt } : {},
-			redemptions: [],
-			...input.metadata ? { metadata: input.metadata } : {},
-			...tenantId ? { [this.config.tenant.field]: tenantId } : {}
-		};
-		const voucher = await this.voucherPort.create(data);
-		this.events.emit(PromoEvents.VOUCHER_GENERATED, {
-			programId: input.programId,
-			voucherIds: [voucher._id],
-			codes: [voucher.code],
-			count: 1,
-			actorId: ctx.actorId
-		});
-		return voucher;
-	}
-	async validateCode(code, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const voucher = await this.voucherPort.getByCode(code, tenantId);
-		if (!voucher) return {
-			valid: false,
-			error: "Voucher not found"
-		};
-		if (voucher.status === "expired") return {
-			valid: false,
-			error: "Voucher has expired"
-		};
-		if (voucher.status === "cancelled") return {
-			valid: false,
-			error: "Voucher has been cancelled"
-		};
-		if (voucher.status === "used") return {
-			valid: false,
-			error: "Voucher has already been used"
-		};
-		if (voucher.expiresAt && voucher.expiresAt < /* @__PURE__ */ new Date()) return {
-			valid: false,
-			error: "Voucher has expired"
-		};
-		if (voucher.usedCount >= voucher.usageLimit) return {
-			valid: false,
-			error: "Voucher has reached its usage limit"
-		};
-		const program = await this.programPort.getById(voucher.programId, tenantId);
-		return {
-			valid: true,
-			voucher: {
-				code: voucher.code,
-				programId: voucher.programId,
-				programType: program?.programType ?? "unknown",
-				status: voucher.status,
-				remainingUses: voucher.usageLimit - voucher.usedCount,
-				...voucher.currentBalance !== void 0 ? { currentBalance: voucher.currentBalance } : {},
-				...voucher.expiresAt ? { expiresAt: voucher.expiresAt } : {}
-			}
-		};
-	}
-	async getByCode(code, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		return this.voucherPort.getByCode(code, getTenantValue(ctx, this.config.tenant));
-	}
-	async getById(id, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		return this.voucherPort.getById(id, getTenantValue(ctx, this.config.tenant));
-	}
-	async cancel(id, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		const voucher = await this.voucherPort.getById(id, tenantId);
-		if (!voucher) throw new VoucherNotFoundError(id);
-		const updated = await this.voucherPort.update(id, { status: "cancelled" }, tenantId);
-		this.events.emit(PromoEvents.VOUCHER_CANCELLED, {
-			voucherId: id,
-			code: voucher.code,
-			status: "cancelled"
-		});
-		return updated;
-	}
-	async redeem(input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		return this.unitOfWork.withTransaction(async (session) => {
-			const voucher = await this.voucherPort.getByCode(input.code, tenantId);
-			if (!voucher) throw new VoucherNotFoundError(input.code);
-			this.assertVoucherUsable(voucher);
-			if (input.idempotencyKey) {
-				if (await this.voucherPort.hasIdempotencyKey(voucher._id, input.idempotencyKey)) throw new DuplicateRedemptionError(input.idempotencyKey);
-			}
-			const redemption = {
-				orderId: input.orderId,
-				customerId: input.customerId,
-				discountAmount: input.discountAmount,
-				redeemedAt: /* @__PURE__ */ new Date(),
-				...input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}
-			};
-			const updated = await this.voucherPort.incrementUsage(voucher._id, redemption, tenantId, session);
-			if (updated.usedCount >= updated.usageLimit) await this.voucherPort.update(voucher._id, { status: "used" }, tenantId, session);
-			this.events.emit(PromoEvents.VOUCHER_REDEEMED, {
-				voucherId: voucher._id,
-				code: voucher.code,
-				orderId: input.orderId,
-				discountAmount: input.discountAmount,
-				customerId: input.customerId
-			});
-			return updated;
-		});
-	}
-	async getBalance(code, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const voucher = await this.voucherPort.getByCode(code, getTenantValue(ctx, this.config.tenant));
-		if (!voucher) throw new VoucherNotFoundError(code);
-		if (voucher.initialBalance === void 0) throw new ValidationError("Voucher is not a gift card");
-		return {
-			code: voucher.code,
-			initialBalance: voucher.initialBalance ?? 0,
-			currentBalance: voucher.currentBalance ?? 0,
-			spent: (voucher.initialBalance ?? 0) - (voucher.currentBalance ?? 0),
-			voucherId: voucher._id
-		};
-	}
-	async spend(input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		if (input.amount <= 0) throw new ValidationError("Spend amount must be positive");
-		return this.unitOfWork.withTransaction(async (session) => {
-			const voucher = await this.voucherPort.getByCode(input.code, tenantId);
-			if (!voucher) throw new VoucherNotFoundError(input.code);
-			this.assertVoucherUsable(voucher);
-			const balance = voucher.currentBalance ?? 0;
-			if (!this.config.giftCard.allowNegativeBalance && balance < input.amount) throw new InsufficientBalanceError(input.code, balance, input.amount);
-			if (input.idempotencyKey) {
-				if (await this.voucherPort.hasIdempotencyKey(voucher._id, input.idempotencyKey)) throw new DuplicateRedemptionError(input.idempotencyKey);
-			}
-			const entry = {
-				amount: -input.amount,
-				orderId: input.orderId,
-				description: input.description ?? `Spent on order ${input.orderId}`,
-				createdAt: /* @__PURE__ */ new Date(),
-				...input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}
-			};
-			const updated = await this.voucherPort.addLedgerEntry(voucher._id, entry, -input.amount, tenantId, session);
-			const newBalance = updated.currentBalance ?? 0;
-			this.events.emit(PromoEvents.GIFT_CARD_SPENT, {
-				voucherId: voucher._id,
-				code: voucher.code,
-				amount: input.amount,
-				remainingBalance: newBalance,
-				orderId: input.orderId
-			});
-			if (newBalance <= 0) {
-				await this.voucherPort.update(voucher._id, { status: "used" }, tenantId, session);
-				this.events.emit(PromoEvents.GIFT_CARD_EXHAUSTED, {
-					voucherId: voucher._id,
-					code: voucher.code,
-					status: "used"
-				});
-			}
-			return {
-				code: updated.code,
-				initialBalance: updated.initialBalance ?? 0,
-				currentBalance: newBalance,
-				spent: (updated.initialBalance ?? 0) - newBalance,
-				voucherId: updated._id
-			};
-		});
-	}
-	async topUp(input, ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		const tenantId = getTenantValue(ctx, this.config.tenant);
-		if (input.amount <= 0) throw new ValidationError("Top-up amount must be positive");
-		const voucher = await this.voucherPort.getByCode(input.code, tenantId);
-		if (!voucher) throw new VoucherNotFoundError(input.code);
-		const maxBalance = this.config.giftCard.maxBalance;
-		if (maxBalance !== null && (voucher.currentBalance ?? 0) + input.amount > maxBalance) throw new ValidationError(`Top-up would exceed max balance of ${maxBalance}`);
-		if (input.idempotencyKey) {
-			if (await this.voucherPort.hasIdempotencyKey(voucher._id, input.idempotencyKey)) throw new DuplicateRedemptionError(input.idempotencyKey);
-		}
-		const entry = {
-			amount: input.amount,
-			description: input.description ?? "Top-up",
-			createdAt: /* @__PURE__ */ new Date(),
-			...input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}
-		};
-		const updated = await this.voucherPort.addLedgerEntry(voucher._id, entry, input.amount, tenantId);
-		if (voucher.status === "used") await this.voucherPort.update(voucher._id, { status: "active" }, tenantId);
-		this.events.emit(PromoEvents.GIFT_CARD_TOPPED_UP, {
-			voucherId: voucher._id,
-			code: voucher.code,
-			amount: input.amount,
-			newBalance: updated.currentBalance ?? 0
-		});
-		return {
-			code: updated.code,
-			initialBalance: updated.initialBalance ?? 0,
-			currentBalance: updated.currentBalance ?? 0,
-			spent: (updated.initialBalance ?? 0) - (updated.currentBalance ?? 0),
-			voucherId: updated._id
-		};
-	}
-	async expireExpired(ctx) {
-		assertTenantContext(ctx, this.config.tenant);
-		return this.voucherPort.expireByDate(/* @__PURE__ */ new Date(), getTenantValue(ctx, this.config.tenant));
-	}
-	assertVoucherUsable(voucher) {
-		if (voucher.status === "expired") throw new VoucherExpiredError(voucher.code);
-		if (voucher.status === "cancelled") throw new VoucherExpiredError(voucher.code);
-		if (voucher.status === "used") throw new VoucherExhaustedError(voucher.code);
-		if (voucher.expiresAt && voucher.expiresAt < /* @__PURE__ */ new Date()) throw new VoucherExpiredError(voucher.code);
-		if (voucher.usedCount >= voucher.usageLimit) throw new VoucherExhaustedError(voucher.code);
-	}
-};
-//#endregion
-//#region src/services/index.ts
-function createServices(deps) {
-	const { repositories, unitOfWork, events, config } = deps;
-	return {
-		program: new ProgramService(repositories.program, repositories.rule, repositories.reward, events, config),
-		voucher: new VoucherService(repositories.voucher, repositories.program, unitOfWork, events, config),
-		evaluation: new EvaluationService(repositories.program, repositories.rule, repositories.reward, repositories.voucher, unitOfWork, events, config)
-	};
-}
-//#endregion
-export { EvaluationService as i, VoucherService as n, ProgramService as r, createServices as t };