@unifiedcommerce/core 0.4.4 → 0.4.5

package/dist/modules/pricing/schemas.js

@@ -0,0 +1,30 @@
+import { z } from "@hono/zod-openapi";
+// ─── Zod Body Schemas (single source of truth) ─────────────────────────────
+export const SetBasePriceBodySchema = z.object({
+    entityId: z.string().openapi({ example: "product-uuid" }),
+    variantId: z.string().optional().openapi({ example: "variant-uuid" }),
+    currency: z.string().length(3).openapi({ example: "USD" }),
+    amount: z.number().openapi({ example: 29.99 }),
+    customerGroupId: z.string().optional(),
+    minQuantity: z.number().int().optional(),
+    maxQuantity: z.number().int().optional(),
+    validFrom: z.coerce.date().optional(),
+    validUntil: z.coerce.date().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("SetBasePriceRequest");
+export const CreateModifierBodySchema = z.object({
+    name: z.string().openapi({ example: "Summer Sale" }),
+    type: z.enum(["percentage_discount", "fixed_discount", "markup", "override"]).openapi({ example: "percentage_discount" }),
+    value: z.number().openapi({ example: 10 }),
+    priority: z.number().int().optional(),
+    entityId: z.string().optional(),
+    variantId: z.string().optional(),
+    customerGroupId: z.string().optional(),
+    currency: z.string().length(3).optional().openapi({ example: "USD" }),
+    minQuantity: z.number().int().optional(),
+    maxQuantity: z.number().int().optional(),
+    conditions: z.record(z.string(), z.unknown()).optional(),
+    validFrom: z.coerce.date().optional(),
+    validUntil: z.coerce.date().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("CreateModifierRequest");

package/dist/modules/pricing/service.d.ts

@@ -0,0 +1,62 @@
+import type { Actor } from "../../auth/types.js";
+import { type Result } from "../../kernel/result.js";
+import type { TxContext } from "../../kernel/database/tx-context.js";
+import type { PricingRepository, Price, PriceModifier } from "./repository/index.js";
+import type { CatalogRepository } from "../catalog/repository/index.js";
+export type PriceModifierType = "percentage_discount" | "fixed_discount" | "markup" | "override";
+interface PricingServiceDeps {
+    repository: PricingRepository;
+    catalogRepository: CatalogRepository;
+}
+export interface PriceResolutionContext {
+    entityId: string;
+    variantId?: string;
+    currency: string;
+    quantity: number;
+    customerId?: string;
+    customerGroupIds?: string[];
+    timestamp?: Date;
+}
+export interface PriceBreakdownStep {
+    label: string;
+    amountBefore: number;
+    delta: number;
+    amountAfter: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ResolvedPrice {
+    baseAmount: number;
+    finalAmount: number;
+    currency: string;
+    appliedModifiers: Array<{
+        id: string;
+        name: string;
+        type: PriceModifierType;
+        delta: number;
+        value: number;
+        priority: number;
+    }>;
+    breakdown: PriceBreakdownStep[];
+    basePriceId: string;
+}
+export type { SetBasePriceInput, CreatePriceModifierInput } from "./schemas.js";
+import type { SetBasePriceInput, CreatePriceModifierInput } from "./schemas.js";
+export declare class PricingService {
+    private deps;
+    private readonly repo;
+    private readonly catalogRepo;
+    constructor(deps: PricingServiceDeps);
+    setBasePrice(input: SetBasePriceInput, actor?: Actor | null, ctx?: TxContext): Promise<Result<Price>>;
+    createModifier(input: CreatePriceModifierInput, actor?: Actor | null, ctx?: TxContext): Promise<Result<PriceModifier>>;
+    listPrices(filter?: {
+        entityId?: string;
+        variantId?: string;
+        currency?: string;
+        customerGroupId?: string;
+    }, ctx?: TxContext): Promise<Result<{
+        prices: Price[];
+        modifiers: PriceModifier[];
+    }>>;
+    resolve(input: PriceResolutionContext, ctx?: TxContext): Promise<Result<ResolvedPrice>>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/modules/pricing/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/modules/pricing/service.ts"],"names":[],"mappings":"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"}

package/dist/modules/pricing/service.js

@@ -0,0 +1,308 @@
+import { resolveOrgId } from "../../auth/org.js";
+import { CommerceNotFoundError, CommerceValidationError, } from "../../kernel/errors.js";
+import { Err, Ok } from "../../kernel/result.js";
+function matchesQuantity(min, max, quantity) {
+    if (min != null && quantity < min)
+        return false;
+    if (max != null && quantity > max)
+        return false;
+    return true;
+}
+function matchesWindow(validFrom, validUntil, timestamp) {
+    if (validFrom && timestamp < validFrom)
+        return false;
+    if (validUntil && timestamp > validUntil)
+        return false;
+    return true;
+}
+function durationScore(validFrom, validUntil) {
+    if (validFrom && validUntil)
+        return validUntil.getTime() - validFrom.getTime();
+    if (validFrom || validUntil)
+        return Number.MAX_SAFE_INTEGER - 1;
+    return Number.MAX_SAFE_INTEGER;
+}
+function quantityRangeWidth(min, max) {
+    if (min != null && max != null)
+        return Math.max(0, max - min);
+    if (min != null || max != null)
+        return Number.MAX_SAFE_INTEGER - 1;
+    return Number.MAX_SAFE_INTEGER;
+}
+function compareBasePriceSpecificity(a, b, context) {
+    const aVariant = context.variantId !== undefined && a.variantId === context.variantId
+        ? 1
+        : 0;
+    const bVariant = context.variantId !== undefined && b.variantId === context.variantId
+        ? 1
+        : 0;
+    if (aVariant !== bVariant)
+        return bVariant - aVariant;
+    const hasGroupA = a.customerGroupId ? 1 : 0;
+    const hasGroupB = b.customerGroupId ? 1 : 0;
+    if (hasGroupA !== hasGroupB)
+        return hasGroupB - hasGroupA;
+    const aRange = quantityRangeWidth(a.minQuantity, a.maxQuantity);
+    const bRange = quantityRangeWidth(b.minQuantity, b.maxQuantity);
+    if (aRange !== bRange)
+        return aRange - bRange;
+    const aDuration = durationScore(a.validFrom, a.validUntil);
+    const bDuration = durationScore(b.validFrom, b.validUntil);
+    if (aDuration !== bDuration)
+        return aDuration - bDuration;
+    return b.createdAt.getTime() - a.createdAt.getTime();
+}
+function resolveModifierDelta(type, value, amountBefore) {
+    switch (type) {
+        case "percentage_discount":
+            return -Math.round((amountBefore * value) / 100);
+        case "fixed_discount":
+            return -value;
+        case "markup":
+            return value;
+        case "override":
+            return value - amountBefore;
+        default:
+            return 0;
+    }
+}
+function toGroupSet(context) {
+    return new Set(context.customerGroupIds ?? []);
+}
+function normalizeCurrency(currency) {
+    return currency.trim().toUpperCase();
+}
+export class PricingService {
+    deps;
+    repo;
+    catalogRepo;
+    constructor(deps) {
+        this.deps = deps;
+        this.repo = deps.repository;
+        this.catalogRepo = deps.catalogRepository;
+    }
+    async setBasePrice(input, actor, ctx) {
+        if (input.amount < 0) {
+            return Err(new CommerceValidationError("Base price amount cannot be negative."));
+        }
+        const entity = await this.catalogRepo.findEntityById(input.entityId, ctx);
+        if (!entity) {
+            return Err(new CommerceNotFoundError("Entity not found for price assignment."));
+        }
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        const priceData = {
+            organizationId: orgId,
+            entityId: input.entityId,
+            currency: normalizeCurrency(input.currency),
+            amount: input.amount,
+            metadata: input.metadata ?? {},
+            variantId: input.variantId ?? null,
+            customerGroupId: input.customerGroupId ?? null,
+            minQuantity: input.minQuantity ?? null,
+            maxQuantity: input.maxQuantity ?? null,
+            validFrom: input.validFrom ?? null,
+            validUntil: input.validUntil ?? null,
+        };
+        const record = await this.repo.createPrice(priceData, ctx);
+        return Ok(record);
+    }
+    async createModifier(input, actor, ctx) {
+        if (!input.name) {
+            return Err(new CommerceValidationError("Modifier name is required."));
+        }
+        // Validate modifier type
+        const validTypes = [
+            "percentage_discount",
+            "fixed_discount",
+            "markup",
+            "override",
+        ];
+        if (!validTypes.includes(input.type)) {
+            return Err(new CommerceValidationError(`Invalid modifier type "${input.type}". Must be one of: ${validTypes.join(", ")}`));
+        }
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        const modifierData = {
+            organizationId: orgId,
+            name: input.name,
+            type: input.type,
+            value: input.value,
+            priority: input.priority ?? 100,
+            conditions: input.conditions ?? {},
+            metadata: input.metadata ?? {},
+            entityId: input.entityId ?? null,
+            variantId: input.variantId ?? null,
+            customerGroupId: input.customerGroupId ?? null,
+            currency: input.currency ? normalizeCurrency(input.currency) : null,
+            minQuantity: input.minQuantity ?? null,
+            maxQuantity: input.maxQuantity ?? null,
+            validFrom: input.validFrom ?? null,
+            validUntil: input.validUntil ?? null,
+        };
+        const modifier = await this.repo.createModifier(modifierData, ctx);
+        return Ok(modifier);
+    }
+    async listPrices(filter, ctx) {
+        // Get all prices for the entity if specified, or filter after retrieval
+        let prices = [];
+        if (filter?.entityId) {
+            prices = await this.repo.findPricesByEntityId(filter.entityId, ctx);
+        }
+        // Note: For full list without entityId, we'd need a findAll method
+        // For now, entityId is typically required for practical use
+        // Apply additional filters
+        if (filter?.variantId !== undefined) {
+            prices = prices.filter((p) => p.variantId === filter.variantId);
+        }
+        if (filter?.currency !== undefined) {
+            const normalizedCurrency = normalizeCurrency(filter.currency);
+            prices = prices.filter((p) => p.currency === normalizedCurrency);
+        }
+        if (filter?.customerGroupId !== undefined) {
+            prices = prices.filter((p) => p.customerGroupId === filter.customerGroupId);
+        }
+        // Get modifiers for the entity
+        let modifiers = [];
+        if (filter?.entityId) {
+            modifiers = await this.repo.findModifiersByEntityId(filter.entityId, ctx);
+        }
+        // Apply additional filters
+        if (filter?.variantId !== undefined) {
+            modifiers = modifiers.filter((m) => m.variantId === filter.variantId);
+        }
+        if (filter?.currency !== undefined) {
+            const normalizedCurrency = normalizeCurrency(filter.currency);
+            modifiers = modifiers.filter((m) => m.currency === null || m.currency === normalizedCurrency);
+        }
+        if (filter?.customerGroupId !== undefined) {
+            modifiers = modifiers.filter((m) => m.customerGroupId === null ||
+                m.customerGroupId === filter.customerGroupId);
+        }
+        return Ok({ prices, modifiers });
+    }
+    async resolve(input, ctx) {
+        const entity = await this.catalogRepo.findEntityById(input.entityId, ctx);
+        if (!entity) {
+            return Err(new CommerceNotFoundError(`Entity ${input.entityId} not found.`));
+        }
+        if (input.quantity <= 0) {
+            return Err(new CommerceValidationError("Quantity must be greater than zero for price resolution."));
+        }
+        const timestamp = input.timestamp ?? new Date();
+        const currency = normalizeCurrency(input.currency);
+        const groupSet = toGroupSet(input);
+        // Get matching prices from repository
+        const allPrices = await this.repo.findPricesByEntityId(input.entityId, ctx);
+        const matchingPrices = allPrices.filter((price) => {
+            if (input.variantId !== undefined) {
+                if (price.variantId !== null && price.variantId !== input.variantId)
+                    return false;
+            }
+            else if (price.variantId !== null) {
+                return false;
+            }
+            if (price.currency !== currency)
+                return false;
+            if (!matchesQuantity(price.minQuantity, price.maxQuantity, input.quantity))
+                return false;
+            if (!matchesWindow(price.validFrom, price.validUntil, timestamp))
+                return false;
+            if (price.customerGroupId !== null &&
+                !groupSet.has(price.customerGroupId))
+                return false;
+            return true;
+        });
+        if (matchingPrices.length === 0) {
+            const metadataPrice = typeof entity.metadata?.basePrice === "number"
+                ? Math.round(entity.metadata.basePrice)
+                : undefined;
+            if (metadataPrice === undefined) {
+                return Err(new CommerceNotFoundError(`No base price configured for ${entity.slug} (${currency}).`));
+            }
+            const fallback = {
+                baseAmount: metadataPrice,
+                finalAmount: metadataPrice,
+                currency,
+                basePriceId: "metadata:basePrice",
+                appliedModifiers: [],
+                breakdown: [
+                    {
+                        label: "Base price (entity metadata)",
+                        amountBefore: metadataPrice,
+                        delta: 0,
+                        amountAfter: metadataPrice,
+                    },
+                ],
+            };
+            return Ok(fallback);
+        }
+        const selectedBase = [...matchingPrices].sort((a, b) => compareBasePriceSpecificity(a, b, input))[0];
+        if (!selectedBase) {
+            return Err(new CommerceNotFoundError("No matching base price could be selected."));
+        }
+        let runningAmount = selectedBase.amount;
+        const breakdown = [
+            {
+                label: "Base price",
+                amountBefore: selectedBase.amount,
+                delta: 0,
+                amountAfter: selectedBase.amount,
+                metadata: {
+                    priceId: selectedBase.id,
+                    customerGroupId: selectedBase.customerGroupId,
+                    minQuantity: selectedBase.minQuantity,
+                    maxQuantity: selectedBase.maxQuantity,
+                },
+            },
+        ];
+        const appliedModifiers = [];
+        // Get matching modifiers (includes both entity-specific and global)
+        const firstGroupId = groupSet.size > 0 ? [...groupSet][0] : undefined;
+        const activeModifiers = await this.repo.findActiveModifiers(input.entityId, input.variantId, firstGroupId, currency, input.quantity, ctx);
+        // Additional filtering for multiple customer groups and conditions
+        const modifiers = activeModifiers
+            .filter((modifier) => {
+            // Re-check customer group for multi-group support
+            if (modifier.customerGroupId !== null &&
+                !groupSet.has(modifier.customerGroupId))
+                return false;
+            const conditions = modifier.conditions;
+            const minSubtotal = conditions?.minSubtotal;
+            if (typeof minSubtotal === "number" && runningAmount < minSubtotal)
+                return false;
+            return true;
+        })
+            .sort((a, b) => a.priority - b.priority);
+        for (const modifier of modifiers) {
+            const amountBefore = runningAmount;
+            const rawDelta = resolveModifierDelta(modifier.type, modifier.value, amountBefore);
+            const delta = Math.max(-amountBefore, rawDelta);
+            runningAmount = Math.max(0, amountBefore + delta);
+            appliedModifiers.push({
+                id: modifier.id,
+                name: modifier.name,
+                type: modifier.type,
+                delta,
+                value: modifier.value,
+                priority: modifier.priority,
+            });
+            breakdown.push({
+                label: `Modifier: ${modifier.name}`,
+                amountBefore,
+                delta,
+                amountAfter: runningAmount,
+                metadata: {
+                    type: modifier.type,
+                    priority: modifier.priority,
+                },
+            });
+        }
+        return Ok({
+            baseAmount: selectedBase.amount,
+            finalAmount: runningAmount,
+            currency,
+            basePriceId: selectedBase.id,
+            appliedModifiers,
+            breakdown,
+        });
+    }
+}

package/dist/modules/promotions/repository/index.d.ts

@@ -0,0 +1,41 @@
+import type { TxContext } from "../../../kernel/database/tx-context.js";
+import type { DrizzleDatabase } from "../../../kernel/database/drizzle-db.js";
+import { promotions, promotionUsages } from "../schema.js";
+export type Promotion = typeof promotions.$inferSelect;
+export type PromotionInsert = typeof promotions.$inferInsert;
+export type PromotionUsage = typeof promotionUsages.$inferSelect;
+export type PromotionUsageInsert = typeof promotionUsages.$inferInsert;
+/**
+ * PromotionsRepository provides type-safe database operations for promotions.
+ *
+ * This repository manages promotions and their usage tracking.
+ * All methods support an optional TxContext parameter for transaction participation.
+ */
+export declare class PromotionsRepository {
+    private readonly db;
+    constructor(db: DrizzleDatabase);
+    private getDb;
+    findById(orgId: string, id: string, ctx?: TxContext): Promise<Promotion | undefined>;
+    findByCode(orgId: string, code: string, ctx?: TxContext): Promise<Promotion | undefined>;
+    findAll(orgId: string, ctx?: TxContext): Promise<Promotion[]>;
+    findActive(orgId: string, ctx?: TxContext): Promise<Promotion[]>;
+    findAutomatic(orgId: string, ctx?: TxContext): Promise<Promotion[]>;
+    create(data: PromotionInsert, ctx?: TxContext): Promise<Promotion>;
+    update(id: string, data: Partial<Omit<PromotionInsert, "id">>, ctx?: TxContext): Promise<Promotion | undefined>;
+    delete(id: string, ctx?: TxContext): Promise<boolean>;
+    activate(id: string, ctx?: TxContext): Promise<Promotion | undefined>;
+    deactivate(id: string, ctx?: TxContext): Promise<Promotion | undefined>;
+    findUsageById(id: string, ctx?: TxContext): Promise<PromotionUsage | undefined>;
+    findUsagesByPromotionId(promotionId: string, ctx?: TxContext): Promise<PromotionUsage[]>;
+    findUsagesByCustomerId(customerId: string, ctx?: TxContext): Promise<PromotionUsage[]>;
+    createUsage(data: PromotionUsageInsert, ctx?: TxContext): Promise<PromotionUsage>;
+    countUsages(promotionId: string, ctx?: TxContext): Promise<number>;
+    countUsagesByCustomer(promotionId: string, customerId: string, ctx?: TxContext): Promise<number>;
+    isUsageLimitReached(orgId: string, promotionId: string, ctx?: TxContext): Promise<boolean>;
+    isCustomerUsageLimitReached(orgId: string, promotionId: string, customerId: string, ctx?: TxContext): Promise<boolean>;
+    isPromotionValid(orgId: string, promotionId: string, customerId?: string, ctx?: TxContext): Promise<{
+        valid: boolean;
+        reason?: string;
+    }>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/promotions/repository/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/promotions/repository/index.ts"],"names":[],"mappings":"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"}

package/dist/modules/promotions/repository/index.js

@@ -0,0 +1,204 @@
+import { eq, and, lte, gte, or, isNull, desc, sql } from "drizzle-orm";
+import { promotions, promotionUsages } from "../schema.js";
+/**
+ * PromotionsRepository provides type-safe database operations for promotions.
+ *
+ * This repository manages promotions and their usage tracking.
+ * All methods support an optional TxContext parameter for transaction participation.
+ */
+export class PromotionsRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getDb(ctx) {
+        return ctx?.tx ?? this.db;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Promotions
+    // ─────────────────────────────────────────────────────────────────────────────
+    async findById(orgId, id, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .select()
+            .from(promotions)
+            .where(and(eq(promotions.organizationId, orgId), eq(promotions.id, id)));
+        return rows[0];
+    }
+    async findByCode(orgId, code, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .select()
+            .from(promotions)
+            .where(and(eq(promotions.organizationId, orgId), eq(promotions.code, code)));
+        return rows[0];
+    }
+    async findAll(orgId, ctx) {
+        const db = this.getDb(ctx);
+        return db
+            .select()
+            .from(promotions)
+            .where(eq(promotions.organizationId, orgId))
+            .orderBy(desc(promotions.priority));
+    }
+    async findActive(orgId, ctx) {
+        const db = this.getDb(ctx);
+        const now = new Date();
+        return db
+            .select()
+            .from(promotions)
+            .where(and(eq(promotions.organizationId, orgId), eq(promotions.isActive, true), or(isNull(promotions.validFrom), lte(promotions.validFrom, now)), or(isNull(promotions.validUntil), gte(promotions.validUntil, now))))
+            .orderBy(desc(promotions.priority));
+    }
+    async findAutomatic(orgId, ctx) {
+        const db = this.getDb(ctx);
+        const now = new Date();
+        return db
+            .select()
+            .from(promotions)
+            .where(and(eq(promotions.organizationId, orgId), eq(promotions.isActive, true), eq(promotions.isAutomatic, true), or(isNull(promotions.validFrom), lte(promotions.validFrom, now)), or(isNull(promotions.validUntil), gte(promotions.validUntil, now))))
+            .orderBy(desc(promotions.priority));
+    }
+    async create(data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db.insert(promotions).values(data).returning();
+        return rows[0];
+    }
+    async update(id, data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .update(promotions)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(promotions.id, id))
+            .returning();
+        return rows[0];
+    }
+    async delete(id, ctx) {
+        const db = this.getDb(ctx);
+        const result = await db
+            .delete(promotions)
+            .where(eq(promotions.id, id))
+            .returning();
+        return result.length > 0;
+    }
+    async activate(id, ctx) {
+        return this.update(id, { isActive: true }, ctx);
+    }
+    async deactivate(id, ctx) {
+        return this.update(id, { isActive: false }, ctx);
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Promotion Usages
+    // ─────────────────────────────────────────────────────────────────────────────
+    async findUsageById(id, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .select()
+            .from(promotionUsages)
+            .where(eq(promotionUsages.id, id));
+        return rows[0];
+    }
+    async findUsagesByPromotionId(promotionId, ctx) {
+        const db = this.getDb(ctx);
+        return db
+            .select()
+            .from(promotionUsages)
+            .where(eq(promotionUsages.promotionId, promotionId));
+    }
+    async findUsagesByCustomerId(customerId, ctx) {
+        const db = this.getDb(ctx);
+        return db
+            .select()
+            .from(promotionUsages)
+            .where(eq(promotionUsages.customerId, customerId));
+    }
+    async createUsage(data, ctx) {
+        const db = this.getDb(ctx);
+        // Atomic guard: use INSERT ... SELECT WHERE count < limit to prevent
+        // race conditions between concurrent checkouts using the same coupon.
+        // A plain count-then-insert has a TOCTOU gap; this single statement
+        // ensures the insert only succeeds if the limit has not been reached.
+        const promo = await db
+            .select({ usageLimitTotal: promotions.usageLimitTotal })
+            .from(promotions)
+            .where(eq(promotions.id, data.promotionId));
+        const limit = promo[0]?.usageLimitTotal;
+        if (limit != null) {
+            // Atomic guard: lock the promotion row and check usage count in the
+            // same statement sequence. This prevents two concurrent checkouts
+            // from both passing the count check (TOCTOU race).
+            //
+            // SELECT ... FOR UPDATE acquires a row-level lock that serializes
+            // concurrent callers. If the caller is already inside a transaction
+            // (ctx.tx), the lock is held until that transaction commits.
+            await db.execute(sql `SELECT id FROM promotions WHERE id = ${data.promotionId} FOR UPDATE`);
+            const currentCount = await this.countUsages(data.promotionId, ctx);
+            if (currentCount >= limit) {
+                throw new Error(`Promotion usage limit reached (${currentCount}/${limit})`);
+            }
+            const rows = await db.insert(promotionUsages).values(data).returning();
+            return rows[0];
+        }
+        const rows = await db.insert(promotionUsages).values(data).returning();
+        return rows[0];
+    }
+    async countUsages(promotionId, ctx) {
+        const db = this.getDb(ctx);
+        const result = await db
+            .select({ count: sql `count(*)::int` })
+            .from(promotionUsages)
+            .where(eq(promotionUsages.promotionId, promotionId));
+        return result[0]?.count ?? 0;
+    }
+    async countUsagesByCustomer(promotionId, customerId, ctx) {
+        const db = this.getDb(ctx);
+        const result = await db
+            .select({ count: sql `count(*)::int` })
+            .from(promotionUsages)
+            .where(and(eq(promotionUsages.promotionId, promotionId), eq(promotionUsages.customerId, customerId)));
+        return result[0]?.count ?? 0;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Validation Helpers
+    // ─────────────────────────────────────────────────────────────────────────────
+    async isUsageLimitReached(orgId, promotionId, ctx) {
+        const promotion = await this.findById(orgId, promotionId, ctx);
+        if (!promotion || promotion.usageLimitTotal === null) {
+            return false;
+        }
+        const count = await this.countUsages(promotionId, ctx);
+        return count >= promotion.usageLimitTotal;
+    }
+    async isCustomerUsageLimitReached(orgId, promotionId, customerId, ctx) {
+        const promotion = await this.findById(orgId, promotionId, ctx);
+        if (!promotion || promotion.usageLimitPerCustomer === null) {
+            return false;
+        }
+        const count = await this.countUsagesByCustomer(promotionId, customerId, ctx);
+        return count >= promotion.usageLimitPerCustomer;
+    }
+    async isPromotionValid(orgId, promotionId, customerId, ctx) {
+        const promotion = await this.findById(orgId, promotionId, ctx);
+        if (!promotion) {
+            return { valid: false, reason: "Promotion not found" };
+        }
+        if (!promotion.isActive) {
+            return { valid: false, reason: "Promotion is not active" };
+        }
+        const now = new Date();
+        if (promotion.validFrom && promotion.validFrom > now) {
+            return { valid: false, reason: "Promotion has not started yet" };
+        }
+        if (promotion.validUntil && promotion.validUntil < now) {
+            return { valid: false, reason: "Promotion has expired" };
+        }
+        if (await this.isUsageLimitReached(orgId, promotionId, ctx)) {
+            return { valid: false, reason: "Promotion usage limit reached" };
+        }
+        if (customerId &&
+            (await this.isCustomerUsageLimitReached(orgId, promotionId, customerId, ctx))) {
+            return { valid: false, reason: "Customer usage limit reached" };
+        }
+        return { valid: true };
+    }
+}