@classytic/promo 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Classytic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @classytic/promo
+
+Promotions engine for MongoDB — discount codes, vouchers, cashback, BOGO, and rule-based pricing.
+
+Framework-agnostic. Works with Fastify (Arc), Express, NestJS, Next.js, or any Node.js app with a Mongoose connection.
+
+## Install
+
+```bash
+npm install @classytic/promo
+# Peer deps:
+npm install mongoose@^9 @classytic/mongokit@^3.5
+```
+
+## Quick Start
+
+```typescript
+import { createPromoEngine } from '@classytic/promo';
+import mongoose from 'mongoose';
+
+const engine = createPromoEngine({
+  mongoose: mongoose.connection,
+  tenant: { field: 'organizationId' }, // multi-tenant (or false for single)
+});
+
+// Create a discount program
+const program = await engine.services.program.create({
+  name: 'Summer Sale',
+  type: 'discount_code',
+  startsAt: new Date(),
+}, ctx);
+
+// Evaluate cart against active promotions
+const result = await engine.services.evaluation.evaluate({
+  cart: { items, subtotal },
+}, ctx);
+```
+
+## License
+
+MIT

package/dist/config-iZjn_8pp.d.mts

@@ -0,0 +1,71 @@
+import { t as EventEmitterPort } from "./event-emitter.port-DaodlJSG.mjs";
+import { Connection } from "mongoose";
+import { PluginType } from "@classytic/mongokit";
+
+//#region src/types/config.d.ts
+interface TenantEnabled {
+  field?: string;
+  ref?: string;
+  type?: 'ObjectId' | 'string';
+  contextKey?: string;
+}
+type TenantConfig = false | TenantEnabled;
+interface IndexDefinition {
+  fields: Record<string, 1 | -1>;
+  options?: Record<string, unknown>;
+}
+type ModelName = 'program' | 'rule' | 'reward' | 'voucher';
+type PluginType$1 = PluginType;
+interface RepositoryPlugins {
+  program?: PluginType[];
+  rule?: PluginType[];
+  reward?: PluginType[];
+  voucher?: PluginType[];
+}
+interface PromoConfig {
+  mongoose: Connection;
+  tenant?: TenantConfig;
+  evaluation?: {
+    maxStackablePromotions?: number;
+    allowExclusiveAndStackable?: boolean;
+  };
+  voucher?: {
+    codeLength?: number;
+    codePrefix?: string;
+    defaultExpiryDays?: number;
+  };
+  giftCard?: {
+    allowNegativeBalance?: boolean;
+    maxBalance?: number;
+  };
+  indexes?: Partial<Record<ModelName, IndexDefinition[]>>;
+  events?: {
+    adapter?: EventEmitterPort;
+  };
+  plugins?: RepositoryPlugins;
+}
+interface ResolvedTenant {
+  enabled: boolean;
+  field: string;
+  ref?: string;
+  type: 'ObjectId' | 'string';
+  contextKey: string;
+}
+interface ResolvedConfig {
+  evaluation: {
+    maxStackablePromotions: number;
+    allowExclusiveAndStackable: boolean;
+  };
+  voucher: {
+    codeLength: number;
+    codePrefix: string;
+    defaultExpiryDays: number | null;
+  };
+  giftCard: {
+    allowNegativeBalance: boolean;
+    maxBalance: number | null;
+  };
+  tenant: ResolvedTenant;
+}
+//#endregion
+export { RepositoryPlugins as a, TenantConfig as c, PromoConfig as i, ModelName as n, ResolvedConfig as o, PluginType$1 as r, ResolvedTenant as s, IndexDefinition as t };

package/dist/constants-BVajdyL3.mjs

@@ -0,0 +1,45 @@
+//#region src/constants.ts
+const PROGRAM_TYPES = [
+	"promotion",
+	"coupon",
+	"discount_code",
+	"buy_x_get_y",
+	"gift_card"
+];
+const TRIGGER_MODES = ["auto", "code"];
+const PROGRAM_STATUSES = [
+	"draft",
+	"active",
+	"paused",
+	"expired",
+	"archived"
+];
+const STACKING_MODES = ["exclusive", "stackable"];
+const REWARD_TYPES = ["discount", "free_product"];
+const DISCOUNT_MODES = ["percentage", "fixed"];
+const DISCOUNT_SCOPES = [
+	"order",
+	"cheapest",
+	"specific_products"
+];
+const VOUCHER_STATUSES = [
+	"active",
+	"used",
+	"expired",
+	"cancelled"
+];
+const DEFAULT_TENANT_FIELD = "organizationId";
+const DEFAULT_TENANT_TYPE = "ObjectId";
+const PROGRAM_TRANSITIONS = {
+	draft: ["active", "archived"],
+	active: [
+		"paused",
+		"expired",
+		"archived"
+	],
+	paused: ["active", "archived"],
+	expired: ["archived"],
+	archived: []
+};
+//#endregion
+export { PROGRAM_STATUSES as a, REWARD_TYPES as c, VOUCHER_STATUSES as d, DISCOUNT_SCOPES as i, STACKING_MODES as l, DEFAULT_TENANT_TYPE as n, PROGRAM_TRANSITIONS as o, DISCOUNT_MODES as r, PROGRAM_TYPES as s, DEFAULT_TENANT_FIELD as t, TRIGGER_MODES as u };

package/dist/domain/enums/index.d.mts

@@ -0,0 +1,2 @@
+import { a as RewardType, c as VoucherStatus, d as PROGRAM_STATUSES, f as PROGRAM_TYPES, g as VOUCHER_STATUSES, h as TRIGGER_MODES, i as ProgramType, l as DISCOUNT_MODES, m as STACKING_MODES, n as DiscountScope, o as StackingMode, p as REWARD_TYPES, r as ProgramStatus, s as TriggerMode, t as DiscountMode, u as DISCOUNT_SCOPES } from "../../index-J5BC20DN.mjs";
+export { DISCOUNT_MODES, DISCOUNT_SCOPES, DiscountMode, DiscountScope, PROGRAM_STATUSES, PROGRAM_TYPES, ProgramStatus, ProgramType, REWARD_TYPES, RewardType, STACKING_MODES, StackingMode, TRIGGER_MODES, TriggerMode, VOUCHER_STATUSES, VoucherStatus };

package/dist/domain/enums/index.mjs

@@ -0,0 +1,2 @@
+import { a as PROGRAM_STATUSES, c as REWARD_TYPES, d as VOUCHER_STATUSES, i as DISCOUNT_SCOPES, l as STACKING_MODES, r as DISCOUNT_MODES, s as PROGRAM_TYPES, u as TRIGGER_MODES } from "../../constants-BVajdyL3.mjs";
+export { DISCOUNT_MODES, DISCOUNT_SCOPES, PROGRAM_STATUSES, PROGRAM_TYPES, REWARD_TYPES, STACKING_MODES, TRIGGER_MODES, VOUCHER_STATUSES };

package/dist/domain/index.d.mts

@@ -0,0 +1,61 @@
+import { a as RewardType, c as VoucherStatus, d as PROGRAM_STATUSES, f as PROGRAM_TYPES, g as VOUCHER_STATUSES, h as TRIGGER_MODES, i as ProgramType, l as DISCOUNT_MODES, m as STACKING_MODES, n as DiscountScope, o as StackingMode, p as REWARD_TYPES, r as ProgramStatus, s as TriggerMode, t as DiscountMode, u as DISCOUNT_SCOPES } from "../index-J5BC20DN.mjs";
+import { a as BalanceLedgerEntry, c as Rule, i as ProgramPort, l as Reward, n as RulePort, o as Voucher, r as RewardPort, s as VoucherRedemption, t as VoucherPort, u as Program } from "../voucher.port-yxfb3MHJ.mjs";
+import { t as EventEmitterPort } from "../event-emitter.port-DaodlJSG.mjs";
+import { n as UnitOfWork, t as TransactionSession } from "../unit-of-work.port-DaMW8WZK.mjs";
+
+//#region src/domain/errors/base.d.ts
+declare abstract class PromoError extends Error {
+  abstract readonly code: string;
+  constructor(message: string);
+}
+//#endregion
+//#region src/domain/errors/domain-errors.d.ts
+declare class ValidationError extends PromoError {
+  readonly code = "VALIDATION_ERROR";
+}
+declare class ProgramNotFoundError extends PromoError {
+  readonly code = "PROGRAM_NOT_FOUND";
+  constructor(id?: string);
+}
+declare class RuleNotFoundError extends PromoError {
+  readonly code = "RULE_NOT_FOUND";
+  constructor(id?: string);
+}
+declare class RewardNotFoundError extends PromoError {
+  readonly code = "REWARD_NOT_FOUND";
+  constructor(id?: string);
+}
+declare class VoucherNotFoundError extends PromoError {
+  readonly code = "VOUCHER_NOT_FOUND";
+  constructor(codeOrId?: string);
+}
+declare class InvalidTransitionError extends PromoError {
+  readonly code = "INVALID_TRANSITION";
+  constructor(from: string, to: string);
+}
+declare class VoucherExpiredError extends PromoError {
+  readonly code = "VOUCHER_EXPIRED";
+  constructor(code: string);
+}
+declare class VoucherExhaustedError extends PromoError {
+  readonly code = "VOUCHER_EXHAUSTED";
+  constructor(code: string);
+}
+declare class InsufficientBalanceError extends PromoError {
+  readonly code = "INSUFFICIENT_BALANCE";
+  constructor(code: string, available: number, requested: number);
+}
+declare class TenantIsolationError extends PromoError {
+  readonly code = "TENANT_ISOLATION";
+  constructor();
+}
+declare class DuplicateRedemptionError extends PromoError {
+  readonly code = "DUPLICATE_REDEMPTION";
+  constructor(key: string);
+}
+declare class EvaluationNotFoundError extends PromoError {
+  readonly code = "EVALUATION_NOT_FOUND";
+  constructor(id: string);
+}
+//#endregion
+export { BalanceLedgerEntry, DISCOUNT_MODES, DISCOUNT_SCOPES, DiscountMode, DiscountScope, DuplicateRedemptionError, EvaluationNotFoundError, EventEmitterPort, InsufficientBalanceError, InvalidTransitionError, PROGRAM_STATUSES, PROGRAM_TYPES, Program, ProgramNotFoundError, ProgramPort, ProgramStatus, ProgramType, PromoError, REWARD_TYPES, Reward, RewardNotFoundError, RewardPort, RewardType, Rule, RuleNotFoundError, RulePort, STACKING_MODES, StackingMode, TRIGGER_MODES, TenantIsolationError, TransactionSession, TriggerMode, UnitOfWork, VOUCHER_STATUSES, ValidationError, Voucher, VoucherExhaustedError, VoucherExpiredError, VoucherNotFoundError, VoucherPort, VoucherRedemption, VoucherStatus };

package/dist/domain/index.mjs

@@ -0,0 +1,4 @@
+import { a as PROGRAM_STATUSES, c as REWARD_TYPES, d as VOUCHER_STATUSES, i as DISCOUNT_SCOPES, l as STACKING_MODES, r as DISCOUNT_MODES, s as PROGRAM_TYPES, u as TRIGGER_MODES } 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, o as RewardNotFoundError, p as PromoError, r as InsufficientBalanceError, s as RuleNotFoundError, t as DuplicateRedemptionError, u as VoucherExhaustedError } from "../domain-errors-BEkXvy5O.mjs";
+import "./enums/index.mjs";
+export { DISCOUNT_MODES, DISCOUNT_SCOPES, DuplicateRedemptionError, EvaluationNotFoundError, InsufficientBalanceError, InvalidTransitionError, PROGRAM_STATUSES, PROGRAM_TYPES, ProgramNotFoundError, PromoError, REWARD_TYPES, RewardNotFoundError, RuleNotFoundError, STACKING_MODES, TRIGGER_MODES, TenantIsolationError, VOUCHER_STATUSES, ValidationError, VoucherExhaustedError, VoucherExpiredError, VoucherNotFoundError };

package/dist/domain-errors-BEkXvy5O.mjs

@@ -0,0 +1,80 @@
+//#region src/domain/errors/base.ts
+var PromoError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+	}
+};
+//#endregion
+//#region src/domain/errors/domain-errors.ts
+var ValidationError = class extends PromoError {
+	code = "VALIDATION_ERROR";
+};
+var ProgramNotFoundError = class extends PromoError {
+	code = "PROGRAM_NOT_FOUND";
+	constructor(id) {
+		super(id ? `Program '${id}' not found` : "Program not found");
+	}
+};
+var RuleNotFoundError = class extends PromoError {
+	code = "RULE_NOT_FOUND";
+	constructor(id) {
+		super(id ? `Rule '${id}' not found` : "Rule not found");
+	}
+};
+var RewardNotFoundError = class extends PromoError {
+	code = "REWARD_NOT_FOUND";
+	constructor(id) {
+		super(id ? `Reward '${id}' not found` : "Reward not found");
+	}
+};
+var VoucherNotFoundError = class extends PromoError {
+	code = "VOUCHER_NOT_FOUND";
+	constructor(codeOrId) {
+		super(codeOrId ? `Voucher '${codeOrId}' not found` : "Voucher not found");
+	}
+};
+var InvalidTransitionError = class extends PromoError {
+	code = "INVALID_TRANSITION";
+	constructor(from, to) {
+		super(`Cannot transition from '${from}' to '${to}'`);
+	}
+};
+var VoucherExpiredError = class extends PromoError {
+	code = "VOUCHER_EXPIRED";
+	constructor(code) {
+		super(`Voucher '${code}' has expired`);
+	}
+};
+var VoucherExhaustedError = class extends PromoError {
+	code = "VOUCHER_EXHAUSTED";
+	constructor(code) {
+		super(`Voucher '${code}' has reached its usage limit`);
+	}
+};
+var InsufficientBalanceError = class extends PromoError {
+	code = "INSUFFICIENT_BALANCE";
+	constructor(code, available, requested) {
+		super(`Voucher '${code}' has insufficient balance: ${available} available, ${requested} requested`);
+	}
+};
+var TenantIsolationError = class extends PromoError {
+	code = "TENANT_ISOLATION";
+	constructor() {
+		super("Tenant context is required but was not provided");
+	}
+};
+var DuplicateRedemptionError = class extends PromoError {
+	code = "DUPLICATE_REDEMPTION";
+	constructor(key) {
+		super(`Duplicate redemption detected for idempotency key '${key}'`);
+	}
+};
+var EvaluationNotFoundError = class extends PromoError {
+	code = "EVALUATION_NOT_FOUND";
+	constructor(id) {
+		super(`Evaluation '${id}' not found or already committed`);
+	}
+};
+//#endregion
+export { ProgramNotFoundError as a, TenantIsolationError as c, VoucherExpiredError as d, VoucherNotFoundError as f, InvalidTransitionError as i, ValidationError as l, EvaluationNotFoundError as n, RewardNotFoundError as o, PromoError as p, InsufficientBalanceError as r, RuleNotFoundError as s, DuplicateRedemptionError as t, VoucherExhaustedError as u };

package/dist/event-emitter.port-DaodlJSG.d.mts

@@ -0,0 +1,8 @@
+//#region src/domain/ports/event-emitter.port.d.ts
+interface EventEmitterPort {
+  emit(event: string, payload: unknown): void;
+  on(event: string, handler: (payload: unknown) => void | Promise<void>): void;
+  off(event: string, handler: (payload: unknown) => void | Promise<void>): void;
+}
+//#endregion
+export { EventEmitterPort as t };

package/dist/event-types-CsTV1FKX.mjs

@@ -0,0 +1,25 @@
+//#region src/events/event-types.ts
+const PromoEvents = {
+	PROGRAM_CREATED: "promo.program.created",
+	PROGRAM_ACTIVATED: "promo.program.activated",
+	PROGRAM_PAUSED: "promo.program.paused",
+	PROGRAM_ARCHIVED: "promo.program.archived",
+	RULE_ADDED: "promo.rule.added",
+	RULE_UPDATED: "promo.rule.updated",
+	RULE_REMOVED: "promo.rule.removed",
+	REWARD_ADDED: "promo.reward.added",
+	REWARD_UPDATED: "promo.reward.updated",
+	REWARD_REMOVED: "promo.reward.removed",
+	VOUCHER_GENERATED: "promo.voucher.generated",
+	VOUCHER_REDEEMED: "promo.voucher.redeemed",
+	VOUCHER_CANCELLED: "promo.voucher.cancelled",
+	VOUCHER_EXPIRED: "promo.voucher.expired",
+	GIFT_CARD_SPENT: "promo.gift_card.spent",
+	GIFT_CARD_TOPPED_UP: "promo.gift_card.topped_up",
+	GIFT_CARD_EXHAUSTED: "promo.gift_card.exhausted",
+	EVALUATION_COMPLETED: "promo.evaluation.completed",
+	EVALUATION_COMMITTED: "promo.evaluation.committed",
+	EVALUATION_ROLLED_BACK: "promo.evaluation.rolled_back"
+};
+//#endregion
+export { PromoEvents as t };

package/dist/events/index.d.mts

@@ -0,0 +1,2 @@
+import { a as ProgramLifecyclePayload, c as RulePayload, d as VoucherRedeemedPayload, f as InProcessEventBus, i as GiftCardToppedUpPayload, l as VoucherGeneratedPayload, n as EvaluationCompletedPayload, o as PromoEvents, r as GiftCardSpentPayload, s as RewardPayload, t as EvaluationCommittedPayload, u as VoucherLifecyclePayload } from "../index-C52zSBkI.mjs";
+export { EvaluationCommittedPayload, EvaluationCompletedPayload, GiftCardSpentPayload, GiftCardToppedUpPayload, InProcessEventBus, ProgramLifecyclePayload, PromoEvents, RewardPayload, RulePayload, VoucherGeneratedPayload, VoucherLifecyclePayload, VoucherRedeemedPayload };

package/dist/events/index.mjs

@@ -0,0 +1,3 @@
+import { t as InProcessEventBus } from "../events-CprEWlN7.mjs";
+import { t as PromoEvents } from "../event-types-CsTV1FKX.mjs";
+export { InProcessEventBus, PromoEvents };

package/dist/events-CprEWlN7.mjs

@@ -0,0 +1,25 @@
+//#region src/events/event-bus.ts
+var InProcessEventBus = class {
+	handlers = /* @__PURE__ */ new Map();
+	emit(event, payload) {
+		const set = this.handlers.get(event);
+		if (!set) return;
+		for (const handler of set) try {
+			const result = handler(payload);
+			if (result && typeof result.catch === "function") result.catch(() => {});
+		} catch {}
+	}
+	on(event, handler) {
+		let set = this.handlers.get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.handlers.set(event, set);
+		}
+		set.add(handler);
+	}
+	off(event, handler) {
+		this.handlers.get(event)?.delete(handler);
+	}
+};
+//#endregion
+export { InProcessEventBus as t };

package/dist/index-B7lLH19a.d.mts

@@ -0,0 +1,13 @@
+import { n as ModelName, s as ResolvedTenant, t as IndexDefinition } from "./config-iZjn_8pp.mjs";
+import { Connection, Model } from "mongoose";
+
+//#region src/models/index.d.ts
+interface PromoModels {
+  Program: Model<unknown>;
+  Rule: Model<unknown>;
+  Reward: Model<unknown>;
+  Voucher: Model<unknown>;
+}
+declare function createModels(connection: Connection, tenant: ResolvedTenant, indexes?: Partial<Record<ModelName, IndexDefinition[]>>): PromoModels;
+//#endregion
+export { createModels as n, PromoModels as t };

package/dist/index-C52zSBkI.d.mts

@@ -0,0 +1,96 @@
+import { t as EventEmitterPort } from "./event-emitter.port-DaodlJSG.mjs";
+
+//#region src/events/event-bus.d.ts
+type Handler = (payload: unknown) => void | Promise<void>;
+declare class InProcessEventBus implements EventEmitterPort {
+  private handlers;
+  emit(event: string, payload: unknown): void;
+  on(event: string, handler: Handler): void;
+  off(event: string, handler: Handler): void;
+}
+//#endregion
+//#region src/events/event-types.d.ts
+declare const PromoEvents: {
+  readonly PROGRAM_CREATED: "promo.program.created";
+  readonly PROGRAM_ACTIVATED: "promo.program.activated";
+  readonly PROGRAM_PAUSED: "promo.program.paused";
+  readonly PROGRAM_ARCHIVED: "promo.program.archived";
+  readonly RULE_ADDED: "promo.rule.added";
+  readonly RULE_UPDATED: "promo.rule.updated";
+  readonly RULE_REMOVED: "promo.rule.removed";
+  readonly REWARD_ADDED: "promo.reward.added";
+  readonly REWARD_UPDATED: "promo.reward.updated";
+  readonly REWARD_REMOVED: "promo.reward.removed";
+  readonly VOUCHER_GENERATED: "promo.voucher.generated";
+  readonly VOUCHER_REDEEMED: "promo.voucher.redeemed";
+  readonly VOUCHER_CANCELLED: "promo.voucher.cancelled";
+  readonly VOUCHER_EXPIRED: "promo.voucher.expired";
+  readonly GIFT_CARD_SPENT: "promo.gift_card.spent";
+  readonly GIFT_CARD_TOPPED_UP: "promo.gift_card.topped_up";
+  readonly GIFT_CARD_EXHAUSTED: "promo.gift_card.exhausted";
+  readonly EVALUATION_COMPLETED: "promo.evaluation.completed";
+  readonly EVALUATION_COMMITTED: "promo.evaluation.committed";
+  readonly EVALUATION_ROLLED_BACK: "promo.evaluation.rolled_back";
+};
+interface ProgramLifecyclePayload {
+  programId: string;
+  programType: string;
+  status: string;
+  actorId?: string;
+}
+interface RulePayload {
+  programId: string;
+  ruleId: string;
+  actorId?: string;
+}
+interface RewardPayload {
+  programId: string;
+  rewardId: string;
+  actorId?: string;
+}
+interface VoucherGeneratedPayload {
+  programId: string;
+  voucherIds: string[];
+  codes: string[];
+  count: number;
+  actorId?: string;
+}
+interface VoucherRedeemedPayload {
+  voucherId: string;
+  code: string;
+  orderId: string;
+  discountAmount: number;
+  customerId?: string;
+}
+interface VoucherLifecyclePayload {
+  voucherId: string;
+  code: string;
+  status: string;
+}
+interface GiftCardSpentPayload {
+  voucherId: string;
+  code: string;
+  amount: number;
+  remainingBalance: number;
+  orderId: string;
+}
+interface GiftCardToppedUpPayload {
+  voucherId: string;
+  code: string;
+  amount: number;
+  newBalance: number;
+}
+interface EvaluationCompletedPayload {
+  evaluationId: string;
+  totalDiscount: number;
+  programsApplied: number;
+  codesUsed: string[];
+  isPreview: boolean;
+}
+interface EvaluationCommittedPayload {
+  evaluationId: string;
+  orderId: string;
+  totalDiscount: number;
+}
+//#endregion
+export { ProgramLifecyclePayload as a, RulePayload as c, VoucherRedeemedPayload as d, InProcessEventBus as f, GiftCardToppedUpPayload as i, VoucherGeneratedPayload as l, EvaluationCompletedPayload as n, PromoEvents as o, GiftCardSpentPayload as r, RewardPayload as s, EvaluationCommittedPayload as t, VoucherLifecyclePayload as u };

package/dist/index-Cu9iwy4v.d.mts

@@ -0,0 +1,99 @@
+import { c as Rule, i as ProgramPort, l as Reward, n as RulePort, o as Voucher, r as RewardPort, t as VoucherPort, u as Program } from "./voucher.port-yxfb3MHJ.mjs";
+import { t as EventEmitterPort } from "./event-emitter.port-DaodlJSG.mjs";
+import { n as UnitOfWork } from "./unit-of-work.port-DaMW8WZK.mjs";
+import { o as ResolvedConfig } from "./config-iZjn_8pp.mjs";
+import { t as PromoRepositories } from "./index-l09KqnlE.mjs";
+import { C as UpdateRuleInput, S as UpdateRewardInput, _ as GiftCardTopUpInput, a as GiftCardBalance, b as RedeemVoucherInput, c as VoucherValidation, d as CreateRewardInput, f as CreateRuleInput, g as GiftCardSpendInput, h as GenerateSingleCodeInput, m as GenerateCodesInput, o as PaginatedResult, p as EvaluateInput, r as EvaluationResult, t as CommitResult, u as CreateProgramInput, v as ListQuery, x as UpdateProgramInput, y as PromoContext } from "./results-Ca5ZCNbN.mjs";
+
+//#region src/services/evaluation.service.d.ts
+declare class EvaluationService {
+  private programPort;
+  private rulePort;
+  private rewardPort;
+  private voucherPort;
+  private unitOfWork;
+  private events;
+  private config;
+  private pendingEvaluations;
+  constructor(programPort: ProgramPort, rulePort: RulePort, rewardPort: RewardPort, voucherPort: VoucherPort, unitOfWork: UnitOfWork, events: EventEmitterPort, config: ResolvedConfig);
+  evaluate(input: EvaluateInput, ctx: PromoContext): Promise<EvaluationResult>;
+  preview(input: EvaluateInput, ctx: PromoContext): Promise<EvaluationResult>;
+  commit(evaluationId: string, orderId: string, ctx: PromoContext): Promise<CommitResult>;
+  rollback(evaluationId: string, ctx: PromoContext): Promise<void>;
+  private doEvaluate;
+  private isCustomerEligible;
+  private matchBestRule;
+  private matchSingleRule;
+  private filterRewardsByRule;
+  private computeDiscount;
+  private getEligibleItems;
+  private describeDiscount;
+}
+//#endregion
+//#region src/services/program.service.d.ts
+interface FullProgram extends Program {
+  rules: Rule[];
+  rewards: Reward[];
+}
+declare class ProgramService {
+  private programPort;
+  private rulePort;
+  private rewardPort;
+  private events;
+  private config;
+  constructor(programPort: ProgramPort, rulePort: RulePort, rewardPort: RewardPort, events: EventEmitterPort, config: ResolvedConfig);
+  create(input: CreateProgramInput, ctx: PromoContext): Promise<Program>;
+  getById(id: string, ctx: PromoContext): Promise<Program>;
+  list(query: ListQuery, ctx: PromoContext): Promise<PaginatedResult<Program>>;
+  update(id: string, input: UpdateProgramInput, ctx: PromoContext): Promise<Program>;
+  activate(id: string, ctx: PromoContext): Promise<Program>;
+  pause(id: string, ctx: PromoContext): Promise<Program>;
+  archive(id: string, ctx: PromoContext): Promise<Program>;
+  private transition;
+  addRule(programId: string, input: CreateRuleInput, ctx: PromoContext): Promise<Rule>;
+  updateRule(programId: string, ruleId: string, input: UpdateRuleInput, ctx: PromoContext): Promise<Rule>;
+  removeRule(programId: string, ruleId: string, ctx: PromoContext): Promise<void>;
+  listRules(programId: string, ctx: PromoContext): Promise<Rule[]>;
+  addReward(programId: string, input: CreateRewardInput, ctx: PromoContext): Promise<Reward>;
+  updateReward(programId: string, rewardId: string, input: UpdateRewardInput, ctx: PromoContext): Promise<Reward>;
+  removeReward(programId: string, rewardId: string, ctx: PromoContext): Promise<void>;
+  listRewards(programId: string, ctx: PromoContext): Promise<Reward[]>;
+  getFullProgram(id: string, ctx: PromoContext): Promise<FullProgram>;
+}
+//#endregion
+//#region src/services/voucher.service.d.ts
+declare class VoucherService {
+  private voucherPort;
+  private programPort;
+  private unitOfWork;
+  private events;
+  private config;
+  constructor(voucherPort: VoucherPort, programPort: ProgramPort, unitOfWork: UnitOfWork, events: EventEmitterPort, config: ResolvedConfig);
+  generateCodes(input: GenerateCodesInput, ctx: PromoContext): Promise<Voucher[]>;
+  generateSingleCode(input: GenerateSingleCodeInput, ctx: PromoContext): Promise<Voucher>;
+  validateCode(code: string, ctx: PromoContext): Promise<VoucherValidation>;
+  getByCode(code: string, ctx: PromoContext): Promise<Voucher | null>;
+  getById(id: string, ctx: PromoContext): Promise<Voucher | null>;
+  cancel(id: string, ctx: PromoContext): Promise<Voucher>;
+  redeem(input: RedeemVoucherInput, ctx: PromoContext): Promise<Voucher>;
+  getBalance(code: string, ctx: PromoContext): Promise<GiftCardBalance>;
+  spend(input: GiftCardSpendInput, ctx: PromoContext): Promise<GiftCardBalance>;
+  topUp(input: GiftCardTopUpInput, ctx: PromoContext): Promise<GiftCardBalance>;
+  expireExpired(ctx: PromoContext): Promise<number>;
+  private assertVoucherUsable;
+}
+//#endregion
+//#region src/services/index.d.ts
+interface PromoServices {
+  program: ProgramService;
+  voucher: VoucherService;
+  evaluation: EvaluationService;
+}
+declare function createServices(deps: {
+  repositories: PromoRepositories;
+  unitOfWork: UnitOfWork;
+  events: EventEmitterPort;
+  config: ResolvedConfig;
+}): PromoServices;
+//#endregion
+export { ProgramService as a, FullProgram as i, createServices as n, EvaluationService as o, VoucherService as r, PromoServices as t };

package/dist/index-J5BC20DN.d.mts

@@ -0,0 +1,21 @@
+//#region src/constants.d.ts
+declare const PROGRAM_TYPES: readonly ["promotion", "coupon", "discount_code", "buy_x_get_y", "gift_card"];
+declare const TRIGGER_MODES: readonly ["auto", "code"];
+declare const PROGRAM_STATUSES: readonly ["draft", "active", "paused", "expired", "archived"];
+declare const STACKING_MODES: readonly ["exclusive", "stackable"];
+declare const REWARD_TYPES: readonly ["discount", "free_product"];
+declare const DISCOUNT_MODES: readonly ["percentage", "fixed"];
+declare const DISCOUNT_SCOPES: readonly ["order", "cheapest", "specific_products"];
+declare const VOUCHER_STATUSES: readonly ["active", "used", "expired", "cancelled"];
+//#endregion
+//#region src/domain/enums/index.d.ts
+type ProgramType = (typeof PROGRAM_TYPES)[number];
+type TriggerMode = (typeof TRIGGER_MODES)[number];
+type ProgramStatus = (typeof PROGRAM_STATUSES)[number];
+type StackingMode = (typeof STACKING_MODES)[number];
+type RewardType = (typeof REWARD_TYPES)[number];
+type DiscountMode = (typeof DISCOUNT_MODES)[number];
+type DiscountScope = (typeof DISCOUNT_SCOPES)[number];
+type VoucherStatus = (typeof VOUCHER_STATUSES)[number];
+//#endregion
+export { RewardType as a, VoucherStatus as c, PROGRAM_STATUSES as d, PROGRAM_TYPES as f, VOUCHER_STATUSES as g, TRIGGER_MODES as h, ProgramType as i, DISCOUNT_MODES as l, STACKING_MODES as m, DiscountScope as n, StackingMode as o, REWARD_TYPES as p, ProgramStatus as r, TriggerMode as s, DiscountMode as t, DISCOUNT_SCOPES as u };