@unifiedcommerce/plugin-loyalty 0.0.1

package/dist/schema.js

@@ -0,0 +1,51 @@
+import { index, integer, boolean, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+import { customers } from "@unifiedcommerce/core/schema";
+import { organization } from "@unifiedcommerce/core/auth-schema";
+export const loyaltyPoints = pgTable("loyalty_points", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    customerId: uuid("customer_id")
+        .notNull()
+        .references(() => customers.id, { onDelete: "cascade" }),
+    points: integer("points").notNull().default(0),
+    tier: text("tier", { enum: ["bronze", "silver", "gold", "platinum"] }).notNull().default("bronze"),
+    lifetimeSpend: integer("lifetime_spend").notNull().default(0),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdx: index("idx_loyalty_points_org").on(table.organizationId),
+    orgCustomerUnique: uniqueIndex("loyalty_points_org_customer_unique").on(table.organizationId, table.customerId),
+}));
+export const loyaltyTransactions = pgTable("loyalty_transactions", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    customerId: uuid("customer_id")
+        .notNull()
+        .references(() => customers.id, { onDelete: "cascade" }),
+    orderId: uuid("order_id"),
+    type: text("type", { enum: ["earn", "redeem"] }).notNull(),
+    amount: integer("amount").notNull(),
+    description: text("description"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdx: index("idx_loyalty_transactions_org").on(table.organizationId),
+    customerIdx: index("idx_loyalty_transactions_customer").on(table.customerId),
+}));
+export const loyaltyRedemptionOffers = pgTable("loyalty_redemption_offers", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    name: text("name").notNull(),
+    pointsRequired: integer("points_required").notNull(),
+    rewardType: text("reward_type", { enum: ["discount_percentage", "discount_fixed", "free_item", "free_shipping"] }).notNull(),
+    rewardValue: integer("reward_value").notNull(),
+    rewardEntityId: uuid("reward_entity_id"),
+    isActive: boolean("is_active").notNull().default(true),
+    validFrom: timestamp("valid_from", { withTimezone: true }),
+    validUntil: timestamp("valid_until", { withTimezone: true }),
+    maxRedemptions: integer("max_redemptions"),
+    timesRedeemed: integer("times_redeemed").notNull().default(0),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdx: index("idx_loyalty_offers_org").on(table.organizationId),
+}));

package/dist/services/loyalty-service.d.ts

@@ -0,0 +1,31 @@
+import type { PluginResult } from "@unifiedcommerce/core";
+import type { Db, LoyaltyPoints, LoyaltyOffer } from "../types";
+export declare class LoyaltyService {
+    private db;
+    private thresholds;
+    constructor(db: Db, thresholds: {
+        silver: number;
+        gold: number;
+        platinum: number;
+    });
+    getPoints(orgId: string, customerId: string): Promise<PluginResult<LoyaltyPoints | null>>;
+    earnPoints(orgId: string, customerId: string, amount: number, orderId?: string): Promise<PluginResult<LoyaltyPoints>>;
+    redeemPoints(orgId: string, customerId: string, amount: number): Promise<PluginResult<LoyaltyPoints>>;
+    getLeaderboard(orgId: string, limit?: number): Promise<PluginResult<LoyaltyPoints[]>>;
+    createOffer(orgId: string, input: {
+        name: string;
+        pointsRequired: number;
+        rewardType: "discount_percentage" | "discount_fixed" | "free_item" | "free_shipping";
+        rewardValue: number;
+        rewardEntityId?: string;
+        validFrom?: string;
+        validUntil?: string;
+        maxRedemptions?: number;
+    }): Promise<PluginResult<LoyaltyOffer>>;
+    listOffers(orgId: string): Promise<PluginResult<LoyaltyOffer[]>>;
+    redeemOffer(orgId: string, customerId: string, offerId: string): Promise<PluginResult<{
+        offer: LoyaltyOffer;
+        remainingPoints: number;
+    }>>;
+}
+//# sourceMappingURL=loyalty-service.d.ts.map

package/dist/services/loyalty-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loyalty-service.d.ts","sourceRoot":"","sources":["../../src/services/loyalty-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,EAAE,EAAE,aAAa,EAAE,YAAY,EAAQ,MAAM,UAAU,CAAC;AAStE,qBAAa,cAAc;IACb,OAAO,CAAC,EAAE;IAAM,OAAO,CAAC,UAAU;gBAA1B,EAAE,EAAE,EAAE,EAAU,UAAU,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;IAE5F,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;IAMzF,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAkCrH,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAwBrG,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,EAAE,CAAC,CAAC;IASjF,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACtC,IAAI,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,qBAAqB,GAAG,gBAAgB,GAAG,WAAW,GAAG,eAAe,CAAC;QAC3H,WAAW,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;KAChH,GAAG,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;IAYjC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC,CAAC;IAMhE,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,KAAK,EAAE,YAAY,CAAC;QAAC,eAAe,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAmB/I"}

package/dist/services/loyalty-service.js

@@ -0,0 +1,118 @@
+import { eq, and, desc, sql } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import { loyaltyPoints, loyaltyTransactions, loyaltyRedemptionOffers } from "../schema";
+function calculateTier(points, thresholds) {
+    if (points >= thresholds.platinum)
+        return "platinum";
+    if (points >= thresholds.gold)
+        return "gold";
+    if (points >= thresholds.silver)
+        return "silver";
+    return "bronze";
+}
+export class LoyaltyService {
+    db;
+    thresholds;
+    constructor(db, thresholds) {
+        this.db = db;
+        this.thresholds = thresholds;
+    }
+    async getPoints(orgId, customerId) {
+        const rows = await this.db.select().from(loyaltyPoints)
+            .where(and(eq(loyaltyPoints.organizationId, orgId), eq(loyaltyPoints.customerId, customerId)));
+        return Ok(rows[0] ?? null);
+    }
+    async earnPoints(orgId, customerId, amount, orderId) {
+        if (amount <= 0)
+            return Err("Amount must be positive");
+        await this.db.insert(loyaltyTransactions).values({
+            organizationId: orgId, customerId, orderId, type: "earn", amount,
+            description: `Earned ${amount} points`,
+        });
+        await this.db.insert(loyaltyPoints).values({
+            organizationId: orgId, customerId, points: amount, lifetimeSpend: 0,
+            tier: calculateTier(amount, this.thresholds),
+        }).onConflictDoUpdate({
+            target: [loyaltyPoints.organizationId, loyaltyPoints.customerId],
+            set: {
+                points: sql `${loyaltyPoints.points} + ${amount}`,
+                updatedAt: new Date(),
+            },
+        });
+        const [updated] = await this.db.select().from(loyaltyPoints)
+            .where(and(eq(loyaltyPoints.organizationId, orgId), eq(loyaltyPoints.customerId, customerId)));
+        if (updated) {
+            const newTier = calculateTier(updated.points, this.thresholds);
+            if (newTier !== updated.tier) {
+                await this.db.update(loyaltyPoints).set({ tier: newTier, updatedAt: new Date() })
+                    .where(and(eq(loyaltyPoints.organizationId, orgId), eq(loyaltyPoints.customerId, customerId)));
+                return Ok({ ...updated, tier: newTier });
+            }
+        }
+        return Ok(updated);
+    }
+    async redeemPoints(orgId, customerId, amount) {
+        if (amount <= 0)
+            return Err("Amount must be positive");
+        // Atomic check-and-deduct: lock the row to prevent concurrent double-spend
+        const [loyalty] = await this.db.select().from(loyaltyPoints)
+            .where(and(eq(loyaltyPoints.organizationId, orgId), eq(loyaltyPoints.customerId, customerId)))
+            .for("update");
+        if (!loyalty)
+            return Err("No loyalty account found");
+        if (loyalty.points < amount)
+            return Err("Not enough points");
+        const newPoints = loyalty.points - amount;
+        const newTier = calculateTier(newPoints, this.thresholds);
+        await this.db.update(loyaltyPoints).set({ points: newPoints, tier: newTier, updatedAt: new Date() })
+            .where(and(eq(loyaltyPoints.organizationId, orgId), eq(loyaltyPoints.customerId, customerId)));
+        await this.db.insert(loyaltyTransactions).values({
+            organizationId: orgId, customerId, type: "redeem", amount,
+            description: `Redeemed ${amount} points`,
+        });
+        return Ok({ ...loyalty, points: newPoints, tier: newTier });
+    }
+    async getLeaderboard(orgId, limit = 10) {
+        const rows = await this.db.select().from(loyaltyPoints)
+            .where(eq(loyaltyPoints.organizationId, orgId))
+            .orderBy(desc(loyaltyPoints.points)).limit(limit);
+        return Ok(rows);
+    }
+    // ─── Offers ────────────────────────────────────────────────────────
+    async createOffer(orgId, input) {
+        const rows = await this.db.insert(loyaltyRedemptionOffers).values({
+            organizationId: orgId, name: input.name, pointsRequired: input.pointsRequired,
+            rewardType: input.rewardType, rewardValue: input.rewardValue,
+            rewardEntityId: input.rewardEntityId,
+            ...(input.validFrom ? { validFrom: new Date(input.validFrom) } : {}),
+            ...(input.validUntil ? { validUntil: new Date(input.validUntil) } : {}),
+            maxRedemptions: input.maxRedemptions,
+        }).returning();
+        return Ok(rows[0]);
+    }
+    async listOffers(orgId) {
+        const rows = await this.db.select().from(loyaltyRedemptionOffers)
+            .where(and(eq(loyaltyRedemptionOffers.organizationId, orgId), eq(loyaltyRedemptionOffers.isActive, true)));
+        return Ok(rows);
+    }
+    async redeemOffer(orgId, customerId, offerId) {
+        // Lock offer row to prevent concurrent over-redemption
+        const [offer] = await this.db.select().from(loyaltyRedemptionOffers)
+            .where(and(eq(loyaltyRedemptionOffers.id, offerId), eq(loyaltyRedemptionOffers.organizationId, orgId)))
+            .for("update");
+        if (!offer)
+            return Err("Offer not found");
+        if (!offer.isActive)
+            return Err("Offer is not active");
+        if (offer.maxRedemptions && offer.timesRedeemed >= offer.maxRedemptions)
+            return Err("Offer fully redeemed");
+        // redeemPoints also uses FOR UPDATE — safe within same transaction context
+        const redeemResult = await this.redeemPoints(orgId, customerId, offer.pointsRequired);
+        if (!redeemResult.ok)
+            return redeemResult;
+        await this.db.update(loyaltyRedemptionOffers)
+            .set({ timesRedeemed: sql `${loyaltyRedemptionOffers.timesRedeemed} + 1`, updatedAt: new Date() })
+            .where(eq(loyaltyRedemptionOffers.id, offerId));
+        return Ok({ offer, remainingPoints: redeemResult.value.points });
+    }
+}