@porulle/core 0.1.0

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 };
+    }
+}

package/dist/modules/promotions/schema.d.ts

@@ -0,0 +1,427 @@
+export declare const promotions: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "promotions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "promotions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        organizationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "organization_id";
+            tableName: "promotions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        code: import("drizzle-orm/pg-core").PgColumn<{
+            name: "code";
+            tableName: "promotions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "promotions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        type: import("drizzle-orm/pg-core").PgColumn<{
+            name: "type";
+            tableName: "promotions";
+            dataType: "string";
+            columnType: "PgText";
+            data: "percentage_off_order" | "fixed_off_order" | "percentage_off_item" | "fixed_off_item" | "free_shipping" | "buy_x_get_y";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["percentage_off_order", "fixed_off_order", "percentage_off_item", "fixed_off_item", "free_shipping", "buy_x_get_y"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        value: import("drizzle-orm/pg-core").PgColumn<{
+            name: "value";
+            tableName: "promotions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        buyQuantity: import("drizzle-orm/pg-core").PgColumn<{
+            name: "buy_quantity";
+            tableName: "promotions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        getQuantity: import("drizzle-orm/pg-core").PgColumn<{
+            name: "get_quantity";
+            tableName: "promotions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isAutomatic: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_automatic";
+            tableName: "promotions";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isActive: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_active";
+            tableName: "promotions";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        priority: import("drizzle-orm/pg-core").PgColumn<{
+            name: "priority";
+            tableName: "promotions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        conditions: import("drizzle-orm/pg-core").PgColumn<{
+            name: "conditions";
+            tableName: "promotions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        usageLimitTotal: import("drizzle-orm/pg-core").PgColumn<{
+            name: "usage_limit_total";
+            tableName: "promotions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        usageLimitPerCustomer: import("drizzle-orm/pg-core").PgColumn<{
+            name: "usage_limit_per_customer";
+            tableName: "promotions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        validFrom: import("drizzle-orm/pg-core").PgColumn<{
+            name: "valid_from";
+            tableName: "promotions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        validUntil: import("drizzle-orm/pg-core").PgColumn<{
+            name: "valid_until";
+            tableName: "promotions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "promotions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "promotions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "promotions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const promotionUsages: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "promotion_usages";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "promotion_usages";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        promotionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "promotion_id";
+            tableName: "promotion_usages";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        customerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "customer_id";
+            tableName: "promotion_usages";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        orderId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "order_id";
+            tableName: "promotion_usages";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        usedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "used_at";
+            tableName: "promotion_usages";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/modules/promotions/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/modules/promotions/schema.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCtB,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe3B,CAAC"}

package/dist/modules/promotions/schema.js

@@ -0,0 +1,52 @@
+import { boolean, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema.js";
+export const promotions = pgTable("promotions", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id")
+        .notNull()
+        .references(() => organization.id, { onDelete: "cascade" }),
+    code: text("code"),
+    name: text("name").notNull(),
+    type: text("type", {
+        enum: [
+            "percentage_off_order",
+            "fixed_off_order",
+            "percentage_off_item",
+            "fixed_off_item",
+            "free_shipping",
+            "buy_x_get_y",
+        ],
+    }).notNull(),
+    value: integer("value").notNull().default(0),
+    buyQuantity: integer("buy_quantity"),
+    getQuantity: integer("get_quantity"),
+    isAutomatic: boolean("is_automatic").notNull().default(false),
+    isActive: boolean("is_active").notNull().default(true),
+    priority: integer("priority").notNull().default(100),
+    conditions: jsonb("conditions").$type().default({}),
+    usageLimitTotal: integer("usage_limit_total"),
+    usageLimitPerCustomer: integer("usage_limit_per_customer"),
+    validFrom: timestamp("valid_from", { withTimezone: true }),
+    validUntil: timestamp("valid_until", { withTimezone: true }),
+    metadata: jsonb("metadata").$type().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    codeIdx: index("idx_promotions_code").on(table.code),
+    activePriorityIdx: index("idx_promotions_active_priority").on(table.isActive, table.priority),
+    validityIdx: index("idx_promotions_validity").on(table.validFrom, table.validUntil),
+    orgIdx: index("idx_promotions_org").on(table.organizationId),
+    orgCodeUnique: uniqueIndex("promotions_org_code_unique").on(table.organizationId, table.code),
+}));
+export const promotionUsages = pgTable("promotion_usages", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    promotionId: uuid("promotion_id")
+        .references(() => promotions.id, { onDelete: "cascade" })
+        .notNull(),
+    customerId: uuid("customer_id"),
+    orderId: uuid("order_id"),
+    usedAt: timestamp("used_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    promotionIdx: index("idx_promotion_usage_promotion").on(table.promotionId),
+    customerIdx: index("idx_promotion_usage_customer").on(table.customerId),
+}));