@unifiedcommerce/core 0.0.1

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";
+import { type Result } from "../../kernel/result";
+import type { TxContext } from "../../kernel/database/tx-context";
+import type { PricingRepository, Price, PriceModifier } from "./repository";
+import type { CatalogRepository } from "../catalog/repository";
+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";
+import type { SetBasePriceInput, CreatePriceModifierInput } from "./schemas";
+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";
+import { CommerceNotFoundError, CommerceValidationError, } from "../../kernel/errors";
+import { Err, Ok } from "../../kernel/result";
+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/in-memory.d.ts

@@ -0,0 +1,32 @@
+import type { TxContext } from "../../../kernel/database/tx-context";
+import type { Promotion, PromotionInsert, PromotionUsage, PromotionUsageInsert } from "./index";
+/**
+ * In-memory implementation of PromotionsRepository for testing.
+ */
+export declare class InMemoryPromotionsRepository {
+    private promotions;
+    private usages;
+    findById(id: string, _ctx?: TxContext): Promise<Promotion | undefined>;
+    findByCode(code: string, _ctx?: TxContext): Promise<Promotion | undefined>;
+    findAll(_ctx?: TxContext): Promise<Promotion[]>;
+    findActive(_ctx?: TxContext): Promise<Promotion[]>;
+    findAutomatic(_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(promotionId: string, _ctx?: TxContext): Promise<boolean>;
+    isCustomerUsageLimitReached(promotionId: string, customerId: string, _ctx?: TxContext): Promise<boolean>;
+    isPromotionValid(promotionId: string, customerId?: string, _ctx?: TxContext): Promise<{
+        valid: boolean;
+        reason?: string;
+    }>;
+}
+//# sourceMappingURL=in-memory.d.ts.map

package/dist/modules/promotions/repository/in-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.d.ts","sourceRoot":"","sources":["../../../../src/modules/promotions/repository/in-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EACf,cAAc,EACd,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAMjB;;GAEG;AACH,qBAAa,4BAA4B;IACvC,OAAO,CAAC,UAAU,CAAgC;IAClD,OAAO,CAAC,MAAM,CAAwB;IAMhC,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAItE,UAAU,CACd,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAI3B,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAM/C,UAAU,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAYlD,aAAa,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAarD,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IAuCnE,MAAM,CACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,EAC1C,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IA2E3B,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAItD,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAItE,UAAU,CACd,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAQ3B,aAAa,CACjB,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAIhC,uBAAuB,CAC3B,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,cAAc,EAAE,CAAC;IAItB,sBAAsB,CAC1B,UAAU,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,cAAc,EAAE,CAAC;IAItB,WAAW,CACf,IAAI,EAAE,oBAAoB,EAC1B,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,cAAc,CAAC;IAYpB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC;IAInE,qBAAqB,CACzB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,MAAM,CAAC;IAMZ,mBAAmB,CACvB,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,OAAO,CAAC;IAOb,2BAA2B,CAC/B,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,OAAO,CAAC;IAWb,gBAAgB,CACpB,WAAW,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAiChD"}

package/dist/modules/promotions/repository/in-memory.js

@@ -0,0 +1,227 @@
+function makeId() {
+    return crypto.randomUUID();
+}
+/**
+ * In-memory implementation of PromotionsRepository for testing.
+ */
+export class InMemoryPromotionsRepository {
+    promotions = new Map();
+    usages = [];
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Promotions
+    // ─────────────────────────────────────────────────────────────────────────────
+    async findById(id, _ctx) {
+        return this.promotions.get(id);
+    }
+    async findByCode(code, _ctx) {
+        return [...this.promotions.values()].find((p) => p.code === code);
+    }
+    async findAll(_ctx) {
+        return [...this.promotions.values()].sort((a, b) => b.priority - a.priority);
+    }
+    async findActive(_ctx) {
+        const now = new Date();
+        return [...this.promotions.values()]
+            .filter((p) => {
+            if (!p.isActive)
+                return false;
+            if (p.validFrom && p.validFrom > now)
+                return false;
+            if (p.validUntil && p.validUntil < now)
+                return false;
+            return true;
+        })
+            .sort((a, b) => b.priority - a.priority);
+    }
+    async findAutomatic(_ctx) {
+        const now = new Date();
+        return [...this.promotions.values()]
+            .filter((p) => {
+            if (!p.isActive)
+                return false;
+            if (!p.isAutomatic)
+                return false;
+            if (p.validFrom && p.validFrom > now)
+                return false;
+            if (p.validUntil && p.validUntil < now)
+                return false;
+            return true;
+        })
+            .sort((a, b) => b.priority - a.priority);
+    }
+    async create(data, _ctx) {
+        // Enforce unique code constraint (nullable: multiple NULLs allowed, but non-null codes must be unique)
+        if (data.code != null) {
+            const duplicate = [...this.promotions.values()].find((p) => p.code === data.code);
+            if (duplicate) {
+                throw new Error(`Promotion with code "${data.code}" already exists.`);
+            }
+        }
+        const now = new Date();
+        const promotion = {
+            id: data.id ?? makeId(),
+            code: data.code === undefined ? null : data.code,
+            name: data.name,
+            type: data.type,
+            value: data.value ?? 0,
+            buyQuantity: data.buyQuantity === undefined ? null : data.buyQuantity,
+            getQuantity: data.getQuantity === undefined ? null : data.getQuantity,
+            isAutomatic: data.isAutomatic ?? false,
+            isActive: data.isActive ?? true,
+            priority: data.priority ?? 100,
+            conditions: data.conditions === undefined ? null : data.conditions,
+            usageLimitTotal: data.usageLimitTotal === undefined ? null : data.usageLimitTotal,
+            usageLimitPerCustomer: data.usageLimitPerCustomer === undefined
+                ? null
+                : data.usageLimitPerCustomer,
+            validFrom: data.validFrom === undefined ? null : data.validFrom,
+            validUntil: data.validUntil === undefined ? null : data.validUntil,
+            metadata: data.metadata === undefined ? null : data.metadata,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.promotions.set(promotion.id, promotion);
+        return promotion;
+    }
+    async update(id, data, _ctx) {
+        const existing = this.promotions.get(id);
+        if (!existing)
+            return undefined;
+        const updated = {
+            id: existing.id,
+            code: data.code !== undefined
+                ? data.code === undefined
+                    ? null
+                    : data.code
+                : existing.code,
+            name: data.name !== undefined ? data.name : existing.name,
+            type: data.type !== undefined ? data.type : existing.type,
+            value: data.value !== undefined ? data.value : existing.value,
+            buyQuantity: data.buyQuantity !== undefined
+                ? data.buyQuantity === undefined
+                    ? null
+                    : data.buyQuantity
+                : existing.buyQuantity,
+            getQuantity: data.getQuantity !== undefined
+                ? data.getQuantity === undefined
+                    ? null
+                    : data.getQuantity
+                : existing.getQuantity,
+            isAutomatic: data.isAutomatic !== undefined
+                ? data.isAutomatic
+                : existing.isAutomatic,
+            isActive: data.isActive !== undefined ? data.isActive : existing.isActive,
+            priority: data.priority !== undefined ? data.priority : existing.priority,
+            conditions: data.conditions !== undefined
+                ? data.conditions === undefined
+                    ? null
+                    : data.conditions
+                : existing.conditions,
+            usageLimitTotal: data.usageLimitTotal !== undefined
+                ? data.usageLimitTotal === undefined
+                    ? null
+                    : data.usageLimitTotal
+                : existing.usageLimitTotal,
+            usageLimitPerCustomer: data.usageLimitPerCustomer !== undefined
+                ? data.usageLimitPerCustomer === undefined
+                    ? null
+                    : data.usageLimitPerCustomer
+                : existing.usageLimitPerCustomer,
+            validFrom: data.validFrom !== undefined
+                ? data.validFrom === undefined
+                    ? null
+                    : data.validFrom
+                : existing.validFrom,
+            validUntil: data.validUntil !== undefined
+                ? data.validUntil === undefined
+                    ? null
+                    : data.validUntil
+                : existing.validUntil,
+            metadata: data.metadata !== undefined
+                ? data.metadata === undefined
+                    ? null
+                    : data.metadata
+                : existing.metadata,
+            createdAt: existing.createdAt,
+            updatedAt: new Date(),
+        };
+        this.promotions.set(id, updated);
+        return updated;
+    }
+    async delete(id, _ctx) {
+        return this.promotions.delete(id);
+    }
+    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) {
+        return this.usages.find((u) => u.id === id);
+    }
+    async findUsagesByPromotionId(promotionId, _ctx) {
+        return this.usages.filter((u) => u.promotionId === promotionId);
+    }
+    async findUsagesByCustomerId(customerId, _ctx) {
+        return this.usages.filter((u) => u.customerId === customerId);
+    }
+    async createUsage(data, _ctx) {
+        const usage = {
+            id: data.id ?? makeId(),
+            promotionId: data.promotionId,
+            customerId: data.customerId ?? null,
+            orderId: data.orderId ?? null,
+            usedAt: data.usedAt ?? new Date(),
+        };
+        this.usages.push(usage);
+        return usage;
+    }
+    async countUsages(promotionId, _ctx) {
+        return this.usages.filter((u) => u.promotionId === promotionId).length;
+    }
+    async countUsagesByCustomer(promotionId, customerId, _ctx) {
+        return this.usages.filter((u) => u.promotionId === promotionId && u.customerId === customerId).length;
+    }
+    async isUsageLimitReached(promotionId, _ctx) {
+        const promotion = await this.findById(promotionId, _ctx);
+        if (!promotion || promotion.usageLimitTotal === null)
+            return false;
+        const count = await this.countUsages(promotionId, _ctx);
+        return count >= promotion.usageLimitTotal;
+    }
+    async isCustomerUsageLimitReached(promotionId, customerId, _ctx) {
+        const promotion = await this.findById(promotionId, _ctx);
+        if (!promotion || promotion.usageLimitPerCustomer === null)
+            return false;
+        const count = await this.countUsagesByCustomer(promotionId, customerId, _ctx);
+        return count >= promotion.usageLimitPerCustomer;
+    }
+    async isPromotionValid(promotionId, customerId, _ctx) {
+        const promotion = await this.findById(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(promotionId, _ctx)) {
+            return { valid: false, reason: "Promotion usage limit reached" };
+        }
+        if (customerId &&
+            (await this.isCustomerUsageLimitReached(promotionId, customerId, _ctx))) {
+            return { valid: false, reason: "Customer usage limit reached" };
+        }
+        return { valid: true };
+    }
+}