@classytic/loyalty 0.1.0

package/dist/index.mjs

@@ -0,0 +1,95 @@
+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";
+//#region src/index.ts
+function resolveConfig(config) {
+	let tenant;
+	if (config.tenant === false) tenant = {
+		enabled: false,
+		field: "",
+		type: "ObjectId",
+		contextKey: ""
+	};
+	else if (config.tenant === void 0) tenant = {
+		enabled: true,
+		field: DEFAULT_TENANT_FIELD,
+		type: 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",
+		...config.tenant.ref ? { ref: config.tenant.ref } : {}
+	};
+	const resolved = {
+		programId: config.program?.id ?? "default",
+		conversionRate: config.program?.conversionRate ?? 10,
+		redemption: {
+			minPoints: config.redemption?.minPoints ?? 0,
+			minOrderAmount: config.redemption?.minOrderAmount ?? 0,
+			maxRedeemPercent: config.redemption?.maxRedeemPercent ?? 50,
+			reservationTtlMinutes: config.redemption?.reservationTtlMinutes ?? 30
+		},
+		referral: {
+			referrerRewardPoints: config.referral?.referrerRewardPoints ?? 100,
+			refereeRewardPoints: config.referral?.refereeRewardPoints ?? 50,
+			maxPerPeriod: config.referral?.maxPerPeriod ?? 10,
+			periodDays: config.referral?.periodDays ?? 30,
+			requireApproval: config.referral?.requireApproval ?? false,
+			codeLength: config.referral?.codeLength ?? 8
+		},
+		expiry: {
+			enabled: config.expiry?.enabled ?? false,
+			...config.expiry?.defaultDays !== void 0 ? { defaultDays: config.expiry.defaultDays } : {}
+		},
+		tenant
+	};
+	if (resolved.conversionRate <= 0) throw new ValidationError("conversionRate must be positive");
+	if (resolved.referral.codeLength < 4) throw new ValidationError("referral codeLength must be >= 4");
+	if (resolved.redemption.maxRedeemPercent < 0 || resolved.redemption.maxRedeemPercent > 100) throw new ValidationError("maxRedeemPercent must be between 0 and 100");
+	return resolved;
+}
+var MongoUnitOfWork = class {
+	constructor(connection) {
+		this.connection = connection;
+	}
+	async withTransaction(cb) {
+		const session = await this.connection.startSession();
+		try {
+			let result;
+			await session.withTransaction(async () => {
+				result = await cb(session);
+			});
+			return result;
+		} finally {
+			await session.endSession();
+		}
+	}
+};
+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 unitOfWork = new MongoUnitOfWork(config.mongoose);
+	const events = config.events?.adapter ?? new InProcessEventBus();
+	return {
+		models,
+		repositories,
+		services: createServices({
+			repositories,
+			unitOfWork,
+			events,
+			notifications: config.notifications ?? null,
+			config: resolvedConfig
+		}),
+		events
+	};
+}
+//#endregion
+export { LoyaltyEvents, createLoyaltyEngine, resolveConfig };

package/dist/models/index.d.mts

@@ -0,0 +1,2 @@
+import { n as createModels, t as LoyaltyModels } from "../index-B6ZstxSP.mjs";
+export { LoyaltyModels, createModels };

package/dist/models/index.mjs

@@ -0,0 +1,2 @@
+import { t as createModels } from "../models-CrZPmVxt.mjs";
+export { createModels };

package/dist/models-CrZPmVxt.mjs

@@ -0,0 +1,417 @@
+import { a as MEMBER_STATUSES, c as RULE_STATUSES, l as RULE_TYPES, o as REDEMPTION_STATUSES, s as REFERRAL_STATUSES, u as TRANSACTION_TYPES } from "./constants-C75GvizO.mjs";
+import mongoose from "mongoose";
+//#region src/models/create-model.ts
+/**
+* Injects the tenant field into a schema and prepends it to ALL existing indexes.
+*/
+function injectTenantField(schema, tenant) {
+	if (!tenant.enabled) return;
+	schema.add({ [tenant.field]: {
+		type: tenant.type === "ObjectId" ? mongoose.Schema.Types.ObjectId : String,
+		required: true,
+		index: true,
+		...tenant.ref ? { ref: tenant.ref } : {}
+	} });
+	const existingIndexes = schema._indexes;
+	if (existingIndexes && existingIndexes.length > 0) for (const indexEntry of existingIndexes) {
+		const fields = indexEntry[0];
+		const newFields = { [tenant.field]: 1 };
+		for (const [key, val] of Object.entries(fields)) newFields[key] = val;
+		indexEntry[0] = newFields;
+	}
+}
+/**
+* Adds user-provided indexes, prepending the tenant field if tenant is enabled.
+*/
+function applyUserIndexes(schema, indexes, tenant) {
+	for (const def of indexes) {
+		const fields = tenant.enabled ? {
+			[tenant.field]: 1,
+			...def.fields
+		} : { ...def.fields };
+		schema.index(fields, def.options ?? {});
+	}
+}
+//#endregion
+//#region src/models/schemas/earning-rule.schema.ts
+function createEarningRuleSchema() {
+	const schema = new mongoose.Schema({
+		programId: {
+			type: String,
+			default: "default"
+		},
+		name: {
+			type: String,
+			required: true
+		},
+		description: { type: String },
+		type: {
+			type: String,
+			enum: RULE_TYPES,
+			required: true
+		},
+		status: {
+			type: String,
+			enum: RULE_STATUSES,
+			default: "active"
+		},
+		priority: {
+			type: Number,
+			default: 0
+		},
+		conditions: {
+			minOrderAmount: { type: Number },
+			categories: [{ type: String }],
+			tiers: [{ type: String }],
+			actions: [{ type: String }],
+			dayOfWeek: [{ type: Number }],
+			dateRange: {
+				start: { type: Date },
+				end: { type: Date }
+			}
+		},
+		reward: {
+			pointsPerAmount: { type: Number },
+			amountPerPoint: { type: Number },
+			fixedPoints: { type: Number },
+			multiplier: { type: Number },
+			roundingMode: {
+				type: String,
+				enum: [
+					"floor",
+					"round",
+					"ceil"
+				],
+				default: "floor"
+			},
+			maxPointsPerTransaction: { type: Number }
+		},
+		startsAt: { type: Date },
+		endsAt: { type: Date },
+		metadata: { type: mongoose.Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		status: 1,
+		type: 1,
+		priority: 1
+	});
+	return schema;
+}
+//#endregion
+//#region src/models/schemas/member.schema.ts
+function createMemberSchema() {
+	const schema = new mongoose.Schema({
+		programId: {
+			type: String,
+			default: "default"
+		},
+		externalId: {
+			type: String,
+			required: true
+		},
+		externalType: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: String,
+			enum: MEMBER_STATUSES,
+			default: "active"
+		},
+		cardId: {
+			type: String,
+			unique: true,
+			sparse: true
+		},
+		referralCode: {
+			type: String,
+			unique: true,
+			sparse: true
+		},
+		tier: {
+			type: String,
+			default: null
+		},
+		tierOverride: { type: String },
+		tierOverrideReason: { type: String },
+		tierQualifiedAt: { type: Date },
+		tierExpiresAt: { type: Date },
+		balance: {
+			current: {
+				type: Number,
+				default: 0
+			},
+			lifetime: {
+				type: Number,
+				default: 0
+			},
+			redeemed: {
+				type: Number,
+				default: 0
+			},
+			expired: {
+				type: Number,
+				default: 0
+			}
+		},
+		enrolledAt: {
+			type: Date,
+			default: Date.now
+		},
+		deactivatedAt: { type: Date },
+		metadata: { type: mongoose.Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		externalId: 1,
+		externalType: 1
+	}, { unique: true });
+	return schema;
+}
+//#endregion
+//#region src/models/schemas/point-transaction.schema.ts
+function createPointTransactionSchema() {
+	const schema = new mongoose.Schema({
+		memberId: {
+			type: mongoose.Schema.Types.ObjectId,
+			required: true,
+			ref: "LoyaltyMember"
+		},
+		programId: {
+			type: String,
+			default: "default"
+		},
+		type: {
+			type: String,
+			enum: TRANSACTION_TYPES,
+			required: true
+		},
+		points: {
+			type: Number,
+			required: true
+		},
+		balanceAfter: {
+			type: Number,
+			required: true
+		},
+		description: {
+			type: String,
+			required: true
+		},
+		referenceType: { type: String },
+		referenceId: { type: String },
+		idempotencyKey: { type: String },
+		earningRuleId: { type: mongoose.Schema.Types.ObjectId },
+		expiresAt: { type: Date },
+		expiredAt: { type: Date },
+		metadata: { type: mongoose.Schema.Types.Mixed },
+		actorId: {
+			type: String,
+			required: true
+		}
+	}, { timestamps: {
+		createdAt: true,
+		updatedAt: false
+	} });
+	schema.index({
+		memberId: 1,
+		createdAt: -1
+	});
+	schema.index({ idempotencyKey: 1 }, {
+		unique: true,
+		partialFilterExpression: { idempotencyKey: {
+			$exists: true,
+			$ne: null
+		} }
+	});
+	return schema;
+}
+//#endregion
+//#region src/models/schemas/redemption.schema.ts
+function createRedemptionSchema() {
+	const schema = new mongoose.Schema({
+		memberId: {
+			type: mongoose.Schema.Types.ObjectId,
+			required: true,
+			ref: "LoyaltyMember"
+		},
+		programId: {
+			type: String,
+			default: "default"
+		},
+		pointsReserved: {
+			type: Number,
+			required: true
+		},
+		pointsConfirmed: {
+			type: Number,
+			default: 0
+		},
+		discountAmount: {
+			type: Number,
+			required: true
+		},
+		conversionRate: {
+			type: Number,
+			required: true
+		},
+		status: {
+			type: String,
+			enum: REDEMPTION_STATUSES,
+			default: "reserved"
+		},
+		ownerType: {
+			type: String,
+			required: true
+		},
+		ownerId: {
+			type: String,
+			required: true
+		},
+		expiresAt: { type: Date },
+		confirmedAt: { type: Date },
+		releasedAt: { type: Date },
+		transactionId: { type: mongoose.Schema.Types.ObjectId }
+	}, { timestamps: true });
+	schema.index({
+		ownerType: 1,
+		ownerId: 1
+	}, { unique: true });
+	return schema;
+}
+//#endregion
+//#region src/models/schemas/referral.schema.ts
+function createReferralSchema() {
+	const schema = new mongoose.Schema({
+		programId: {
+			type: String,
+			default: "default"
+		},
+		referrerId: {
+			type: mongoose.Schema.Types.ObjectId,
+			required: true,
+			ref: "LoyaltyMember"
+		},
+		refereeId: {
+			type: mongoose.Schema.Types.ObjectId,
+			required: true,
+			ref: "LoyaltyMember"
+		},
+		referralCode: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: String,
+			enum: REFERRAL_STATUSES,
+			default: "pending"
+		},
+		referrerRewardPoints: { type: Number },
+		refereeRewardPoints: { type: Number },
+		referrerTransactionId: { type: mongoose.Schema.Types.ObjectId },
+		refereeTransactionId: { type: mongoose.Schema.Types.ObjectId },
+		approvedAt: { type: Date },
+		rejectedAt: { type: Date },
+		rejectionReason: { type: String },
+		expiresAt: { type: Date },
+		metadata: { type: mongoose.Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({ refereeId: 1 }, { unique: true });
+	schema.index({
+		referrerId: 1,
+		createdAt: -1
+	});
+	return schema;
+}
+//#endregion
+//#region src/models/schemas/tier-definition.schema.ts
+function createTierDefinitionSchema() {
+	const schema = new mongoose.Schema({
+		programId: {
+			type: String,
+			default: "default"
+		},
+		name: {
+			type: String,
+			required: true
+		},
+		rank: {
+			type: Number,
+			required: true
+		},
+		qualificationCriteria: {
+			minLifetimePoints: { type: Number },
+			minLifetimeSpend: { type: Number },
+			evaluationPeriodDays: { type: Number }
+		},
+		benefits: {
+			pointsMultiplier: { type: Number },
+			discountPercent: { type: Number },
+			freeShipping: { type: Boolean },
+			customBenefits: { type: mongoose.Schema.Types.Mixed }
+		},
+		downgrade: {
+			enabled: {
+				type: Boolean,
+				default: false
+			},
+			gracePeriodDays: {
+				type: Number,
+				default: 30
+			}
+		},
+		color: { type: String },
+		metadata: { type: mongoose.Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		programId: 1,
+		rank: 1
+	}, { unique: true });
+	schema.index({
+		programId: 1,
+		name: 1
+	}, { unique: true });
+	return schema;
+}
+//#endregion
+//#region src/models/index.ts
+function createModels(connection, tenant, indexes) {
+	const memberSchema = createMemberSchema();
+	const pointTransactionSchema = createPointTransactionSchema();
+	const earningRuleSchema = createEarningRuleSchema();
+	const tierDefinitionSchema = createTierDefinitionSchema();
+	const redemptionSchema = createRedemptionSchema();
+	const referralSchema = createReferralSchema();
+	if (tenant.enabled) {
+		injectTenantField(memberSchema, tenant);
+		injectTenantField(pointTransactionSchema, tenant);
+		injectTenantField(earningRuleSchema, tenant);
+		injectTenantField(tierDefinitionSchema, tenant);
+		injectTenantField(redemptionSchema, tenant);
+		injectTenantField(referralSchema, tenant);
+	}
+	if (indexes) {
+		const schemaMap = {
+			member: memberSchema,
+			pointTransaction: pointTransactionSchema,
+			earningRule: earningRuleSchema,
+			tierDefinition: tierDefinitionSchema,
+			redemption: redemptionSchema,
+			referral: referralSchema
+		};
+		for (const [modelName, defs] of Object.entries(indexes)) {
+			const schema = schemaMap[modelName];
+			if (schema && defs) applyUserIndexes(schema, defs, tenant);
+		}
+	}
+	const model = (name, schema) => connection.models[name] || connection.model(name, schema);
+	return {
+		Member: model("LoyaltyMember", memberSchema),
+		PointTransaction: model("LoyaltyPointTransaction", pointTransactionSchema),
+		EarningRule: model("LoyaltyEarningRule", earningRuleSchema),
+		TierDefinition: model("LoyaltyTierDefinition", tierDefinitionSchema),
+		Redemption: model("LoyaltyRedemption", redemptionSchema),
+		Referral: model("LoyaltyReferral", referralSchema)
+	};
+}
+//#endregion
+export { createModels as t };

package/dist/notification.port-BzUsH0It.d.mts

@@ -0,0 +1,13 @@
+//#region src/domain/ports/notification.port.d.ts
+/**
+ * Optional notification adapter. Implement to receive loyalty events
+ * and dispatch notifications through your own system (email, SMS, push, in-app).
+ *
+ * The loyalty engine calls this adapter after every state change.
+ * The adapter decides what to send, how, and to whom.
+ */
+interface NotificationAdapter {
+  notify(event: string, payload: Record<string, unknown>): void | Promise<void>;
+}
+//#endregion
+export { NotificationAdapter as t };

package/dist/notifications/index.d.mts

@@ -0,0 +1,21 @@
+import { t as NotificationAdapter } from "../notification.port-BzUsH0It.mjs";
+
+//#region src/notifications/index.d.ts
+interface NotificationsAdapterConfig {
+  service: {
+    send: (payload: unknown) => Promise<unknown>;
+  };
+  resolveRecipient: (payload: Record<string, unknown>) => Promise<{
+    id?: string;
+    email?: string;
+    phone?: string;
+    name?: string;
+    deviceToken?: string;
+  } | null>;
+  templates?: Record<string, string>;
+  channels?: Record<string, string[]>;
+  skip?: string[];
+}
+declare function createNotificationsAdapter(config: NotificationsAdapterConfig): NotificationAdapter;
+//#endregion
+export { NotificationsAdapterConfig, createNotificationsAdapter };

package/dist/notifications/index.mjs

@@ -0,0 +1,19 @@
+//#region src/notifications/index.ts
+function createNotificationsAdapter(config) {
+	return { async notify(event, payload) {
+		if (config.skip?.includes(event)) return;
+		const template = config.templates?.[event];
+		if (config.templates && !template) return;
+		const recipient = await config.resolveRecipient(payload);
+		if (!recipient) return;
+		await config.service.send({
+			event,
+			recipient,
+			data: payload,
+			template,
+			channels: config.channels?.[event]
+		});
+	} };
+}
+//#endregion
+export { createNotificationsAdapter };

package/dist/repositories/index.d.mts

@@ -0,0 +1,2 @@
+import { a as RedemptionRepository, c as EarningRuleRepository, i as ReferralRepository, n as createRepositories, o as PointTransactionRepository, r as TierDefinitionRepository, s as MemberRepository, t as LoyaltyRepositories } from "../index-BcoGeDco.mjs";
+export { EarningRuleRepository, LoyaltyRepositories, MemberRepository, PointTransactionRepository, RedemptionRepository, ReferralRepository, TierDefinitionRepository, createRepositories };

package/dist/repositories/index.mjs

@@ -0,0 +1,2 @@
+import { a as PointTransactionRepository, i as RedemptionRepository, n as TierDefinitionRepository, o as MemberRepository, r as ReferralRepository, s as EarningRuleRepository, t as createRepositories } from "../repositories-qMX7Xh_y.mjs";
+export { EarningRuleRepository, MemberRepository, PointTransactionRepository, RedemptionRepository, ReferralRepository, TierDefinitionRepository, createRepositories };