@classytic/loyalty 0.1.0 → 0.2.0

package/dist/index-qI1WvtNg.d.mts

@@ -0,0 +1,361 @@
+import { i as ReferralStatus, r as RedemptionStatus } from "./index-DMK8a98J.mjs";
+import { S as EarningRule, _ as TierEvaluationBatch, d as EarningResult, f as ExpirationResult, g as TierEvaluation, h as RedemptionValidation, o as LoyaltyContext, v as PointTransaction, x as TierDefinition, y as Member } from "./index-2izQQext.mjs";
+import { t as NotificationAdapter } from "./notification.port-9B5xlzxQ.mjs";
+import { c as ResolvedTenant, o as RepositoryPlugins, s as ResolvedConfig } from "./config-JYTMP1F7.mjs";
+import { LoyaltyModels } from "./models/index.mjs";
+import { EventTransport } from "@classytic/primitives/events";
+import { ClientSession, Model } from "mongoose";
+import { PluginType, Repository } from "@classytic/mongokit";
+import { OutboxStore } from "@classytic/primitives/outbox";
+
+//#region src/domain/ports/unit-of-work.port.d.ts
+interface UnitOfWork {
+  withTransaction<T>(callback: (session: ClientSession) => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/repositories/member.repository.d.ts
+declare class MemberRepository extends Repository<Member> {
+  events: EventTransport;
+  outbox: OutboxStore | undefined;
+  notifications: NotificationAdapter | null;
+  config: ResolvedConfig;
+  /** Session-bound outbox save + transport publish (PACKAGE_RULES §5.5 + P8). */
+  private _dispatch;
+  constructor(model: Model<Member>, plugins?: PluginType[]);
+  /**
+   * Auto-inject the tenant id from the repo options into the doc so writes
+   * persist with the correct `organizationId` even when the host has opted
+   * OUT of the auto-wired `multiTenantPlugin` (e.g. arc hosts that scope at
+   * the framework layer). Matches `@classytic/order` / `@classytic/promo`.
+   * No-op when the payload already carries the field.
+   */
+  create(data: Parameters<Repository<Member>['create']>[0], options?: Parameters<Repository<Member>['create']>[1]): Promise<Member>;
+  createMany(docs: Parameters<Repository<Member>['createMany']>[0], options?: Parameters<Repository<Member>['createMany']>[1]): Promise<Member[]>;
+  /**
+   * Atomic balance increment -- uses $inc to prevent TOCTOU races.
+   * Returns the updated member document.
+   */
+  updateBalance(id: string, balanceUpdate: Record<string, number>, ctx?: Record<string, unknown>): Promise<Member>;
+  /** Fetches a member by ID (tenant-scoped via plugin) or throws MemberNotFoundError. */
+  requireMember(memberId: string, ctx?: Record<string, unknown>): Promise<Member>;
+  /** Fetches an active member (tenant-scoped via plugin) or throws MemberNotFoundError / MemberInactiveError. */
+  requireActiveMember(memberId: string, ctx?: Record<string, unknown>): Promise<Member>;
+  enroll(input: {
+    externalId: string;
+    externalType: string;
+    programId?: string;
+    tier?: string;
+    cardId?: string;
+    metadata?: Record<string, unknown>;
+  }, ctx: LoyaltyContext): Promise<Member>;
+  deactivate(memberId: string, ctx: LoyaltyContext): Promise<Member>;
+  reactivate(memberId: string, ctx: LoyaltyContext): Promise<Member>;
+  suspend(memberId: string, reason: string, ctx: LoyaltyContext): Promise<Member>;
+}
+//#endregion
+//#region src/repositories/point-transaction.repository.d.ts
+declare class PointTransactionRepository extends Repository<PointTransaction> {
+  memberRepo: MemberRepository;
+  events: EventTransport;
+  outbox: OutboxStore | undefined;
+  notifications: NotificationAdapter | null;
+  unitOfWork: UnitOfWork;
+  config: ResolvedConfig;
+  constructor(model: Model<PointTransaction>, plugins?: PluginType[]);
+  /** Session-bound outbox save + transport publish (PACKAGE_RULES §5.5 + P8). */
+  private _dispatch;
+  /**
+   * Auto-inject tenant id from options into doc payload. Matches
+   * `@classytic/order` / `@classytic/promo` — see MemberRepository.
+   */
+  create(data: Parameters<Repository<PointTransaction>['create']>[0], options?: Parameters<Repository<PointTransaction>['create']>[1]): Promise<PointTransaction>;
+  createMany(docs: Parameters<Repository<PointTransaction>['createMany']>[0], options?: Parameters<Repository<PointTransaction>['createMany']>[1]): Promise<PointTransaction[]>;
+  earnPoints(input: {
+    memberId: string;
+    points: number;
+    description: string;
+    referenceType?: string;
+    referenceId?: string;
+    earningRuleId?: string;
+    expiresAt?: Date;
+    idempotencyKey?: string;
+    metadata?: Record<string, unknown>;
+  }, ctx: LoyaltyContext): Promise<PointTransaction>;
+  /**
+   * Fans out `earnPoints` across many members for bulk-issuance campaigns
+   * (welcome bonuses, holiday boosts, win-back). Per-member failures do
+   * NOT abort the batch — they surface in `errors[]` with the memberId +
+   * message, matching `@classytic/commission`'s `ingestSplit` shape.
+   *
+   * Idempotency: each row derives its key as `${source.eventId}:${memberId}`
+   * so retrying the whole batch collapses onto the same transactions.
+   *
+   * Events: emits exactly ONE `CAMPAIGN_AWARDED` with aggregate counts —
+   * NOT one-per-member, to avoid an event storm for large batches. The
+   * underlying `POINTS_EARNED` events still fire (one per successful row)
+   * for ledger consumers that need per-member granularity.
+   */
+  awardBatch(members: Array<{
+    memberId: string;
+    points: number;
+  }>, source: {
+    eventId: string;
+    campaignId: string;
+    description: string;
+    referenceType?: string;
+    referenceId?: string;
+    expiresAt?: Date;
+    metadata?: Record<string, unknown>;
+  }, ctx: LoyaltyContext): Promise<{
+    awarded: number;
+    skipped: number;
+    errors: Array<{
+      memberId: string;
+      error: string;
+    }>;
+    totalPoints: number;
+  }>;
+  adjustPoints(input: {
+    memberId: string;
+    points: number;
+    description: string;
+    reason: string;
+    referenceType?: string;
+    referenceId?: string;
+    idempotencyKey?: string;
+    metadata?: Record<string, unknown>;
+  }, ctx: LoyaltyContext): Promise<PointTransaction>;
+  processExpirations(ctx: LoyaltyContext): Promise<ExpirationResult>;
+}
+//#endregion
+//#region src/repositories/earning-rule.repository.d.ts
+declare class EarningRuleRepository extends Repository<EarningRule> {
+  memberRepo: MemberRepository;
+  txRepo: PointTransactionRepository;
+  config: ResolvedConfig;
+  constructor(model: Model<EarningRule>, plugins?: PluginType[]);
+  /** Auto-inject tenant id from options into doc payload. See MemberRepository. */
+  create(data: Parameters<Repository<EarningRule>['create']>[0], options?: Parameters<Repository<EarningRule>['create']>[1]): Promise<EarningRule>;
+  createMany(docs: Parameters<Repository<EarningRule>['createMany']>[0], options?: Parameters<Repository<EarningRule>['createMany']>[1]): Promise<EarningRule[]>;
+  evaluateOrder(input: {
+    memberId: string;
+    orderId: string;
+    orderTotal: number;
+    items?: Array<{
+      categoryId?: string;
+      amount: number;
+      quantity: number;
+    }>;
+  }, ctx: LoyaltyContext): Promise<EarningResult>;
+  evaluateAction(input: {
+    memberId: string;
+    action: string;
+    referenceId?: string;
+  }, ctx: LoyaltyContext): Promise<EarningResult>;
+  private matchesConditions;
+  private calculateOrderPoints;
+  private calculateCategoryPoints;
+  private applyRounding;
+}
+//#endregion
+//#region src/domain/entities/redemption.d.ts
+interface Redemption {
+  _id: string;
+  memberId: string;
+  programId: string;
+  pointsReserved: number;
+  pointsConfirmed: number;
+  discountAmount: number;
+  conversionRate: number;
+  status: RedemptionStatus;
+  ownerType: string;
+  ownerId: string;
+  expiresAt?: Date;
+  confirmedAt?: Date;
+  releasedAt?: Date;
+  reversedAt?: Date;
+  reversalReason?: string;
+  /** Point transaction id for the compensating credit created by `reverseConfirmed`. */
+  reversalTransactionId?: string;
+  /** Point transaction id for the `redeem` debit created at `confirm()` time. */
+  transactionId?: string;
+  /**
+   * Optional voucher-like partial-use tracking populated by hosts when
+   * the redemption is backed by a gift voucher / reward card. When
+   * present, `reverseConfirmed({ proportional: true })` credits back
+   * `(remainingBalance / initialBalance) × pointsConfirmed`.
+   */
+  initialBalance?: number;
+  remainingBalance?: number;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#endregion
+//#region src/repositories/redemption.repository.d.ts
+declare class RedemptionRepository extends Repository<Redemption> {
+  memberRepo: MemberRepository;
+  txRepo: PointTransactionRepository;
+  events: EventTransport;
+  outbox: OutboxStore | undefined;
+  notifications: NotificationAdapter | null;
+  unitOfWork: UnitOfWork;
+  config: ResolvedConfig;
+  constructor(model: Model<Redemption>, plugins?: PluginType[]);
+  /** Auto-inject tenant id from options into doc payload. See MemberRepository. */
+  create(data: Parameters<Repository<Redemption>['create']>[0], options?: Parameters<Repository<Redemption>['create']>[1]): Promise<Redemption>;
+  createMany(docs: Parameters<Repository<Redemption>['createMany']>[0], options?: Parameters<Repository<Redemption>['createMany']>[1]): Promise<Redemption[]>;
+  /** Session-bound outbox save + transport publish (PACKAGE_RULES §5.5 + P8). */
+  private _dispatch;
+  /**
+   * Atomic compare-and-set status transition.
+   * Returns null if the current status doesn't match `expectedStatus` (CAS mismatch).
+   */
+  atomicStatusTransition(id: string, expectedStatus: string, data: Record<string, unknown>, ctx?: Record<string, unknown>): Promise<Redemption | null>;
+  validate(input: {
+    memberId: string;
+    pointsToRedeem: number;
+    orderTotal: number;
+  }, ctx: LoyaltyContext): Promise<RedemptionValidation>;
+  reserve(input: {
+    memberId: string;
+    pointsToRedeem: number;
+    orderTotal: number;
+    ownerType: string;
+    ownerId: string;
+    expiresAt?: Date;
+  }, ctx: LoyaltyContext): Promise<Redemption>;
+  confirm(redemptionId: string, ctx: LoyaltyContext): Promise<Redemption>;
+  release(redemptionId: string, ctx: LoyaltyContext): Promise<Redemption>;
+  /**
+   * Reverses a confirmed redemption. Credits points back to the member as
+   * a compensating `adjust` transaction, marks the redemption `reversed`,
+   * and emits `REDEMPTION_REVERSED`. Guarded by an atomic CAS on
+   * `status === 'confirmed'` so idempotent callers never double-credit.
+   *
+   * @param options.proportional - when true + the redemption has a
+   *   `remainingBalance` + `initialBalance` (voucher-backed), credits
+   *   back `(remainingBalance / initialBalance) × pointsConfirmed`.
+   *   When false (default), credits back the full `pointsConfirmed`.
+   *   When true but the redemption has no voucher metadata, falls back
+   *   to a full reversal and stamps `metadata.proportional_fallback`.
+   * @param options.reason - free-text audit note; persisted on the
+   *   redemption + the compensating point_transaction metadata.
+   */
+  reverseConfirmed(redemptionId: string, ctx: LoyaltyContext, options?: {
+    proportional?: boolean;
+    reason?: string;
+  }): Promise<Redemption>;
+  cleanupExpired(ctx: LoyaltyContext): Promise<number>;
+}
+//#endregion
+//#region src/domain/entities/referral.d.ts
+interface Referral {
+  _id: string;
+  programId: string;
+  referrerId: string;
+  refereeId: string;
+  referralCode: string;
+  status: ReferralStatus;
+  referrerRewardPoints?: number;
+  refereeRewardPoints?: number;
+  referrerTransactionId?: string;
+  refereeTransactionId?: string;
+  approvedAt?: Date;
+  rejectedAt?: Date;
+  rejectionReason?: string;
+  expiresAt?: Date;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#endregion
+//#region src/repositories/referral.repository.d.ts
+declare class ReferralRepository extends Repository<Referral> {
+  memberRepo: MemberRepository;
+  txRepo: PointTransactionRepository;
+  events: EventTransport;
+  outbox: OutboxStore | undefined;
+  notifications: NotificationAdapter | null;
+  config: ResolvedConfig;
+  constructor(model: Model<Referral>, plugins?: PluginType[]);
+  /** Session-bound outbox save + transport publish (PACKAGE_RULES §5.5 + P8). */
+  private _dispatch;
+  /** Auto-inject tenant id from options into doc payload. See MemberRepository. */
+  create(data: Parameters<Repository<Referral>['create']>[0], options?: Parameters<Repository<Referral>['create']>[1]): Promise<Referral>;
+  createMany(docs: Parameters<Repository<Referral>['createMany']>[0], options?: Parameters<Repository<Referral>['createMany']>[1]): Promise<Referral[]>;
+  /**
+   * Atomic compare-and-set status transition.
+   * Returns null if the current status doesn't match `expectedStatus`.
+   */
+  atomicStatusTransition(id: string, expectedStatus: string, data: Record<string, unknown>, ctx?: Record<string, unknown>): Promise<Referral | null>;
+  generateCode(memberId: string, ctx: LoyaltyContext): Promise<string>;
+  lookupByCode(code: string, ctx: LoyaltyContext): Promise<Member | null>;
+  recordReferral(input: {
+    referralCode: string;
+    refereeExternalId: string;
+    refereeExternalType: string;
+  }, ctx: LoyaltyContext): Promise<Referral>;
+  approve(referralId: string, ctx: LoyaltyContext): Promise<Referral>;
+  reject(referralId: string, reason: string, ctx: LoyaltyContext): Promise<Referral>;
+  cleanupExpired(ctx: LoyaltyContext): Promise<number>;
+  private rewardBothSides;
+  private requireReferral;
+}
+//#endregion
+//#region src/repositories/tier-definition.repository.d.ts
+declare class TierDefinitionRepository extends Repository<TierDefinition> {
+  memberRepo: MemberRepository;
+  events: EventTransport;
+  outbox: OutboxStore | undefined;
+  notifications: NotificationAdapter | null;
+  config: ResolvedConfig;
+  constructor(model: Model<TierDefinition>, plugins?: PluginType[]);
+  /** Auto-inject tenant id from options into doc payload. See MemberRepository. */
+  create(data: Parameters<Repository<TierDefinition>['create']>[0], options?: Parameters<Repository<TierDefinition>['create']>[1]): Promise<TierDefinition>;
+  createMany(docs: Parameters<Repository<TierDefinition>['createMany']>[0], options?: Parameters<Repository<TierDefinition>['createMany']>[1]): Promise<TierDefinition[]>;
+  /** Session-bound outbox save + transport publish (PACKAGE_RULES §5.5 + P8). */
+  private _dispatch;
+  evaluateMember(memberId: string, ctx: LoyaltyContext): Promise<TierEvaluation>;
+  evaluateAll(ctx: LoyaltyContext): Promise<TierEvaluationBatch>;
+  setOverride(memberId: string, tierName: string, reason: string, ctx: LoyaltyContext, options?: {
+    expiresAt?: Date;
+  }): Promise<Member>;
+  clearOverride(memberId: string, ctx: LoyaltyContext): Promise<TierEvaluation>;
+  /**
+   * Sweeps members whose `tierOverrideExpiresAt` is past `now` and clears
+   * the override. Emits `TIER_OVERRIDE_EXPIRED` per member — distinct from
+   * the explicit `TIER_OVERRIDE_CLEARED` event — so audit logs can tell
+   * admin-initiated clears from TTL sweeps.
+   *
+   * Hosts call this on a cron schedule (e.g. hourly). Returns the number
+   * of overrides cleared. No-op when nothing matches.
+   */
+  sweepExpiredOverrides(ctx: LoyaltyContext, now?: Date): Promise<{
+    cleared: number;
+  }>;
+  private applyUpgrade;
+  private applyDowngrade;
+}
+//#endregion
+//#region src/repositories/index.d.ts
+interface LoyaltyRepositories {
+  member: MemberRepository;
+  pointTransaction: PointTransactionRepository;
+  earningRule: EarningRuleRepository;
+  tierDefinition: TierDefinitionRepository;
+  redemption: RedemptionRepository;
+  referral: ReferralRepository;
+}
+interface CreateRepositoriesInput {
+  models: LoyaltyModels;
+  plugins?: RepositoryPlugins;
+  tenant?: ResolvedTenant;
+  config: ResolvedConfig;
+  events: EventTransport;
+  outbox?: OutboxStore | undefined;
+  notifications: NotificationAdapter | null;
+  unitOfWork: UnitOfWork;
+}
+declare function createRepositories(input: CreateRepositoriesInput): LoyaltyRepositories;
+//#endregion
+export { ReferralRepository as a, Redemption as c, MemberRepository as d, UnitOfWork as f, TierDefinitionRepository as i, EarningRuleRepository as l, LoyaltyRepositories as n, Referral as o, createRepositories as r, RedemptionRepository as s, CreateRepositoriesInput as t, PointTransactionRepository as u };

package/dist/index.d.mts

@@ -1,21 +1,37 @@
-import { a as PointTransaction, n as TierDefinition, o as Member, s as MemberBalance, u as EarningRule } from "./tier-definition-Djf72UPa.mjs";
-import { l as Referral, u as Redemption } from "./tier-definition.port-BzrHYBRo.mjs";
-import { t as EventEmitterPort } from "./event-emitter.port-CLYPoMni.mjs";
-import { n as LoyaltyEvents } from "./index-O7TL4R2P.mjs";
-import { n as LoyaltyConfig, o as ResolvedConfig, s as ResolvedTenant } from "./config-aNigy4ec.mjs";
-import { t as LoyaltyModels } from "./index-B6ZstxSP.mjs";
-import { t as LoyaltyRepositories } from "./index-BcoGeDco.mjs";
-import { a as EnrollInput, c as UpdateTierInput, d as EarningResult, g as TierEvaluation, h as RedemptionValidation, i as EarnPointsInput, l as BalanceSummary, n as CreateEarningRuleInput, o as LoyaltyContext, r as CreateTierInput, s as UpdateEarningRuleInput, t as AdjustPointsInput } from "./index-DqzTjeEB.mjs";
-import { n as LoyaltyServices } from "./index-_pg4J11t.mjs";
+import { A as TierUpgraded, B as PointsEarnedPayload, C as ReferralRecorded, D as TierGraceStarted, E as TierDowngraded, F as LoyaltyEventPayload, G as TierChangedPayload, H as RedemptionPayload, I as LoyaltyEvents, J as InProcessLoyaltyBus, L as MemberLifecyclePayload, N as LoyaltyEventMap, P as LoyaltyEventName, S as ReferralApproved, T as ReferralRewarded, V as PointsExpiredPayload, W as ReferralPayload, Y as InProcessLoyaltyBusOptions, _ as PointsRedeemed, a as LoyaltyEventDefinition, b as RedemptionReserved, c as MemberDeactivated, d as MemberSuspended, g as PointsExpiringSoon, h as PointsExpired, j as loyaltyEventDefinitions, l as MemberEnrolled, m as PointsEarned, o as LoyaltyEventPayloadOf, p as PointsAdjusted, q as createEvent, s as LoyaltyEventSchema, u as MemberReactivated, v as RedemptionConfirmed, w as ReferralRejected, y as RedemptionReleased, z as PointsAdjustedPayload } from "./index-BmqGuj38.mjs";
+import { S as EarningRule, a as EnrollInput, b as MemberBalance, c as UpdateTierInput, d as EarningResult, g as TierEvaluation, h as RedemptionValidation, i as EarnPointsInput, l as BalanceSummary, n as CreateEarningRuleInput, o as LoyaltyContext, r as CreateTierInput, s as UpdateEarningRuleInput, t as AdjustPointsInput, v as PointTransaction, x as TierDefinition, y as Member } from "./index-2izQQext.mjs";
+import { t as NotificationAdapter } from "./notification.port-9B5xlzxQ.mjs";
+import { c as ResolvedTenant, n as LoyaltyConfig, r as LoyaltyModelName, s as ResolvedConfig } from "./config-JYTMP1F7.mjs";
+import { LoyaltyModels } from "./models/index.mjs";
+import { a as ReferralRepository, c as Redemption, d as MemberRepository, f as UnitOfWork, i as TierDefinitionRepository, l as EarningRuleRepository, n as LoyaltyRepositories, o as Referral, s as RedemptionRepository, u as PointTransactionRepository } from "./index-qI1WvtNg.mjs";
+import { DomainEvent, EventHandler, EventTransport, EventTransport as EventTransport$1 } from "@classytic/primitives/events";
 
 //#region src/index.d.ts
 declare function resolveConfig(config: LoyaltyConfig): ResolvedConfig;
+/**
+ * LoyaltyEngine -- repositories + arc-compatible event transport.
+ *
+ * Domain verbs live on the repositories themselves (`engine.repositories.member.enroll(...)`,
+ * `engine.repositories.pointTransaction.earnPoints(...)`, etc.). There is no separate
+ * service layer. See PACKAGE_RULES S1-S3.
+ *
+ * `events` is structurally identical to `@classytic/arc`'s `EventTransport`.
+ * Hosts can pass any arc transport (Memory/Redis/Kafka) via `eventTransport`
+ * and subscribe glob-style:
+ *
+ *     const loyalty = createLoyaltyEngine({
+ *       mongoose,
+ *       eventTransport: new RedisEventTransport({ url }),
+ *     });
+ *
+ *     await loyalty.events.subscribe('loyalty.points.*', handler);
+ */
 interface LoyaltyEngine {
   models: LoyaltyModels;
   repositories: LoyaltyRepositories;
-  services: LoyaltyServices;
-  events: EventEmitterPort;
+  events: EventTransport$1;
+  syncIndexes(): Promise<void>;
 }
 declare function createLoyaltyEngine(config: LoyaltyConfig): LoyaltyEngine;
 //#endregion
-export { type AdjustPointsInput, type BalanceSummary, type CreateEarningRuleInput, type CreateTierInput, type EarnPointsInput, type EarningResult, type EarningRule, type EnrollInput, type EventEmitterPort, type LoyaltyConfig, type LoyaltyContext, LoyaltyEngine, LoyaltyEvents, type LoyaltyModels, type LoyaltyRepositories, type LoyaltyServices, type Member, type MemberBalance, type PointTransaction, type Redemption, type RedemptionValidation, type Referral, type ResolvedConfig, type ResolvedTenant, type TierDefinition, type TierEvaluation, type UpdateEarningRuleInput, type UpdateTierInput, createLoyaltyEngine, resolveConfig };
+export { type AdjustPointsInput, type BalanceSummary, type CreateEarningRuleInput, type CreateTierInput, type DomainEvent, type EarnPointsInput, type EarningResult, type EarningRule, EarningRuleRepository, type EnrollInput, type EventHandler, type EventTransport, InProcessLoyaltyBus, type InProcessLoyaltyBusOptions, type LoyaltyConfig, type LoyaltyContext, LoyaltyEngine, type LoyaltyEventDefinition, type LoyaltyEventMap, type LoyaltyEventName, type LoyaltyEventPayload, type LoyaltyEventPayloadOf, type LoyaltyEventSchema, LoyaltyEvents, type LoyaltyModelName, type LoyaltyModels, type LoyaltyRepositories, type Member, type MemberBalance, MemberDeactivated, MemberEnrolled, type MemberLifecyclePayload, MemberReactivated, MemberRepository, MemberSuspended, type NotificationAdapter, type PointTransaction, PointTransactionRepository, PointsAdjusted, type PointsAdjustedPayload, PointsEarned, type PointsEarnedPayload, PointsExpired, type PointsExpiredPayload, PointsExpiringSoon, PointsRedeemed, type Redemption, RedemptionConfirmed, type RedemptionPayload, RedemptionReleased, RedemptionRepository, RedemptionReserved, type RedemptionValidation, type Referral, ReferralApproved, type ReferralPayload, ReferralRecorded, ReferralRejected, ReferralRepository, ReferralRewarded, type ResolvedConfig, type ResolvedTenant, type TierChangedPayload, type TierDefinition, TierDefinitionRepository, TierDowngraded, type TierEvaluation, TierGraceStarted, TierUpgraded, type UnitOfWork, type UpdateEarningRuleInput, type UpdateTierInput, createEvent, createLoyaltyEngine, loyaltyEventDefinitions, resolveConfig };

package/dist/index.mjs

@@ -1,30 +1,28 @@
-import { n as DEFAULT_TENANT_FIELD, r as DEFAULT_TENANT_TYPE } from "./constants-C75GvizO.mjs";
-import { h as ValidationError } from "./domain-errors-D7q-2LYD.mjs";
-import { t as InProcessEventBus } from "./events-CprEWlN7.mjs";
-import { t as createModels } from "./models-CrZPmVxt.mjs";
-import { t as createRepositories } from "./repositories-qMX7Xh_y.mjs";
-import { t as createServices } from "./services-CoTqC4E6.mjs";
-import { t as LoyaltyEvents } from "./event-types-xQBtYBbX.mjs";
+import { n as DEFAULT_TENANT_FIELD, r as DEFAULT_TENANT_TYPE } from "./constants-DkQYkOK1.mjs";
+import { a as PointTransactionRepository, c as ValidationError, i as RedemptionRepository, n as TierDefinitionRepository, o as MemberRepository, r as ReferralRepository, s as EarningRuleRepository, t as createRepositories } from "./repositories-ObGUgcSH.mjs";
+import { E as InProcessLoyaltyBus, T as loyaltyEventDefinitions, _ as ReferralRecorded, a as MemberSuspended, b as TierDowngraded, c as PointsEarned, d as PointsRedeemed, f as RedemptionConfirmed, g as ReferralApproved, i as MemberReactivated, l as PointsExpired, m as RedemptionReserved, n as MemberDeactivated, p as RedemptionReleased, r as MemberEnrolled, s as PointsAdjusted, u as PointsExpiringSoon, v as ReferralRejected, w as TierUpgraded, x as TierGraceStarted, y as ReferralRewarded } from "./events-BjzHSLBn.mjs";
+import { n as createModels } from "./models-uhh9c-7k.mjs";
+import { n as createEvent, t as LoyaltyEvents } from "./loyalty-events-Cyt9TwX6.mjs";
 //#region src/index.ts
 function resolveConfig(config) {
 	let tenant;
 	if (config.tenant === false) tenant = {
 		enabled: false,
-		field: "",
-		type: "ObjectId",
-		contextKey: ""
+		tenantField: DEFAULT_TENANT_FIELD,
+		fieldType: DEFAULT_TENANT_TYPE,
+		contextKey: DEFAULT_TENANT_FIELD
 	};
 	else if (config.tenant === void 0) tenant = {
 		enabled: true,
-		field: DEFAULT_TENANT_FIELD,
-		type: DEFAULT_TENANT_TYPE,
+		tenantField: DEFAULT_TENANT_FIELD,
+		fieldType: DEFAULT_TENANT_TYPE,
 		contextKey: DEFAULT_TENANT_FIELD
 	};
 	else tenant = {
 		enabled: true,
-		field: config.tenant.field ?? "organizationId",
-		type: config.tenant.type ?? "ObjectId",
-		contextKey: config.tenant.contextKey ?? config.tenant.field ?? "organizationId",
+		tenantField: config.tenant.tenantField ?? "organizationId",
+		fieldType: config.tenant.fieldType ?? "objectId",
+		contextKey: config.tenant.contextKey ?? config.tenant.tenantField ?? "organizationId",
 		...config.tenant.ref ? { ref: config.tenant.ref } : {}
 	};
 	const resolved = {
@@ -42,7 +40,9 @@ function resolveConfig(config) {
 			maxPerPeriod: config.referral?.maxPerPeriod ?? 10,
 			periodDays: config.referral?.periodDays ?? 30,
 			requireApproval: config.referral?.requireApproval ?? false,
-			codeLength: config.referral?.codeLength ?? 8
+			codeLength: config.referral?.codeLength ?? 8,
+			maxDepth: Math.max(1, config.referral?.maxDepth ?? 1),
+			tierRates: config.referral?.tierRates ?? [100]
 		},
 		expiry: {
 			enabled: config.expiry?.enabled ?? false,
@@ -74,22 +74,26 @@ var MongoUnitOfWork = class {
 };
 function createLoyaltyEngine(config) {
 	const resolvedConfig = resolveConfig(config);
-	const models = createModels(config.mongoose, resolvedConfig.tenant, config.indexes);
-	const repositories = createRepositories(models, config.plugins, resolvedConfig.tenant.field);
+	const models = createModels(config.mongoose, resolvedConfig.tenant, config.indexes, config.autoIndex, config.collectionPrefix, config.forceRecreate);
 	const unitOfWork = new MongoUnitOfWork(config.mongoose);
-	const events = config.events?.adapter ?? new InProcessEventBus();
+	const events = config.eventTransport ?? new InProcessLoyaltyBus();
 	return {
 		models,
-		repositories,
-		services: createServices({
-			repositories,
-			unitOfWork,
+		repositories: createRepositories({
+			models,
+			plugins: config.plugins,
+			tenant: resolvedConfig.tenant,
+			config: resolvedConfig,
 			events,
+			outbox: config.outbox,
 			notifications: config.notifications ?? null,
-			config: resolvedConfig
+			unitOfWork
 		}),
-		events
+		events,
+		async syncIndexes() {
+			await Promise.all(Object.values(models).map((m) => m.createIndexes()));
+		}
 	};
 }
 //#endregion
-export { LoyaltyEvents, createLoyaltyEngine, resolveConfig };
+export { EarningRuleRepository, InProcessLoyaltyBus, LoyaltyEvents, MemberDeactivated, MemberEnrolled, MemberReactivated, MemberRepository, MemberSuspended, PointTransactionRepository, PointsAdjusted, PointsEarned, PointsExpired, PointsExpiringSoon, PointsRedeemed, RedemptionConfirmed, RedemptionReleased, RedemptionRepository, RedemptionReserved, ReferralApproved, ReferralRecorded, ReferralRejected, ReferralRepository, ReferralRewarded, TierDefinitionRepository, TierDowngraded, TierGraceStarted, TierUpgraded, createEvent, createLoyaltyEngine, loyaltyEventDefinitions, resolveConfig };

package/dist/loyalty-events-Cyt9TwX6.mjs

@@ -0,0 +1,50 @@
+import { createEvent } from "@classytic/primitives/events";
+//#region src/events/helpers.ts
+function createEvent$1(type, payload, ctx, meta) {
+	return createEvent(type, payload, {
+		userId: ctx?.actorId,
+		organizationId: ctx?.organizationId,
+		...meta
+	});
+}
+//#endregion
+//#region src/events/loyalty-events.ts
+/**
+* Loyalty event name + payload map.
+*
+* Minimal surface. Loyalty emits events for its own lifecycle transitions
+* only — member, points ledger, tier, redemption, and referral.
+*
+* For registration with an arc-compatible event registry, see
+* `loyalty-event-catalog.ts` in this directory — it exposes each event as
+* a `LoyaltyEventDefinition` with a Zod payload schema + JSON Schema
+* derived via `z.toJSONSchema()` (PACKAGE_RULES §18.5).
+*/
+const LoyaltyEvents = {
+	MEMBER_ENROLLED: "loyalty.member.enrolled",
+	MEMBER_DEACTIVATED: "loyalty.member.deactivated",
+	MEMBER_REACTIVATED: "loyalty.member.reactivated",
+	MEMBER_SUSPENDED: "loyalty.member.suspended",
+	POINTS_EARNED: "loyalty.points.earned",
+	POINTS_REDEEMED: "loyalty.points.redeemed",
+	POINTS_ADJUSTED: "loyalty.points.adjusted",
+	POINTS_EXPIRED: "loyalty.points.expired",
+	POINTS_EXPIRING_SOON: "loyalty.points.expiring_soon",
+	TIER_UPGRADED: "loyalty.tier.upgraded",
+	TIER_DOWNGRADED: "loyalty.tier.downgraded",
+	TIER_GRACE_STARTED: "loyalty.tier.grace_started",
+	TIER_OVERRIDE_CLEARED: "loyalty.tier.override_cleared",
+	TIER_OVERRIDE_EXPIRED: "loyalty.tier.override_expired",
+	REDEMPTION_RESERVED: "loyalty.redemption.reserved",
+	REDEMPTION_CONFIRMED: "loyalty.redemption.confirmed",
+	REDEMPTION_RELEASED: "loyalty.redemption.released",
+	REDEMPTION_REVERSED: "loyalty.redemption.reversed",
+	CAMPAIGN_AWARDED: "loyalty.campaign.awarded",
+	REFERRAL_RECORDED: "loyalty.referral.recorded",
+	REFERRAL_APPROVED: "loyalty.referral.approved",
+	REFERRAL_REJECTED: "loyalty.referral.rejected",
+	REFERRAL_REWARDED: "loyalty.referral.rewarded",
+	MULTI_TIER_REFERRAL_AWARDED: "loyalty.referral.multi_tier_awarded"
+};
+//#endregion
+export { createEvent$1 as n, LoyaltyEvents as t };