includio-cms 0.24.0 → 0.25.0

package/dist/admin/remote/shop.remote.d.ts

@@ -77,7 +77,7 @@ export declare const reorderShippingMethodsCmd: import("@sveltejs/kit").RemoteCo
     success: boolean;
 }>>;
 export declare const listOrdersAdmin: import("@sveltejs/kit").RemoteQueryFunction<{
-    status?: "done" | "new" | "awaitingPayment" | "paid" | "preparing" | "sent" | "cancelled" | "paymentRejected" | undefined;
+    status?: "done" | "new" | "awaitingPayment" | "paid" | "preparing" | "sent" | "cancelled" | "paymentRejected" | "refunded" | undefined;
     email?: string | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
@@ -173,7 +173,7 @@ export declare const getOrderForAdmin: import("@sveltejs/kit").RemoteQueryFuncti
 } | null>;
 export declare const updateOrderStatusCmd: import("@sveltejs/kit").RemoteCommand<{
     orderId: string;
-    status: "done" | "new" | "awaitingPayment" | "paid" | "preparing" | "sent" | "cancelled" | "paymentRejected";
+    status: "done" | "new" | "awaitingPayment" | "paid" | "preparing" | "sent" | "cancelled" | "paymentRejected" | "refunded";
     note?: string | undefined;
 }, Promise<{
     number: string;
@@ -211,7 +211,7 @@ export declare const updateOrderStatusCmd: import("@sveltejs/kit").RemoteCommand
 }>>;
 export declare const resendOrderEmailCmd: import("@sveltejs/kit").RemoteCommand<{
     orderId: string;
-    status: "done" | "new" | "awaitingPayment" | "paid" | "preparing" | "sent" | "cancelled" | "paymentRejected";
+    status: "done" | "new" | "awaitingPayment" | "paid" | "preparing" | "sent" | "cancelled" | "paymentRejected" | "refunded";
 }, Promise<{
     success: boolean;
 }>>;
@@ -246,3 +246,122 @@ export declare const listShopableCollections: import("@sveltejs/kit").RemoteQuer
         plural?: import("../../types/languages.js").Localized;
     } | undefined;
 }[]>;
+export declare const getOrderRefundsAdmin: import("@sveltejs/kit").RemoteQueryFunction<string, {
+    refunds: {
+        id: string;
+        status: import("../../db-postgres/schema/shop/index.js").ShopRefundStatus;
+        createdAt: Date;
+        updatedAt: Date;
+        currency: string;
+        orderId: string;
+        provider: string;
+        providerRef: string | null;
+        amount: number;
+        paymentId: string | null;
+        reason: string | null;
+        createdBy: string | null;
+    }[];
+    refundedAmount: number;
+    remainingRefundable: number;
+    refundSupported: boolean;
+    paymentMethod: string | null;
+    currency: string;
+    totalGross: number;
+} | null>;
+export declare const refundOrderCmd: import("@sveltejs/kit").RemoteCommand<{
+    orderId: string;
+    amount?: number | undefined;
+    reason?: string | undefined;
+}, Promise<{
+    refund: import("../../shop/server/refund.js").ShopRefundRow;
+    remainingRefundable: number;
+    orderStatusChanged: boolean;
+    success: true;
+    code?: undefined;
+    error?: undefined;
+} | {
+    success: false;
+    code: "order_not_found" | "order_not_paid" | "no_provider_ref" | "unknown_provider" | "refund_unsupported" | "invalid_amount" | "amount_exceeds_remaining" | "provider_error";
+    error: string;
+}>>;
+export declare const listCouponsAdmin: import("@sveltejs/kit").RemoteQueryFunction<void, {
+    id: string;
+    code: string;
+    type: import("../../db-postgres/schema/shop/index.js").ShopCouponType;
+    value: string;
+    minOrderAmount: number | null;
+    maxUses: number | null;
+    usedCount: number;
+    expiresAt: Date | null;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}[]>;
+export declare const getCouponAdmin: import("@sveltejs/kit").RemoteQueryFunction<string, {
+    id: string;
+    code: string;
+    type: import("../../db-postgres/schema/shop/index.js").ShopCouponType;
+    value: string;
+    minOrderAmount: number | null;
+    maxUses: number | null;
+    usedCount: number;
+    expiresAt: Date | null;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}>;
+export declare const createCouponCmd: import("@sveltejs/kit").RemoteCommand<{
+    code: string;
+    type: "fixed" | "percent";
+    value: number;
+    minOrderAmount?: number | null | undefined;
+    maxUses?: number | null | undefined;
+    expiresAt?: string | null | undefined;
+    isActive?: boolean | undefined;
+}, Promise<{
+    code: string;
+    id: string;
+    type: import("../../db-postgres/schema/shop/index.js").ShopCouponType;
+    createdAt: Date;
+    updatedAt: Date;
+    isActive: boolean;
+    expiresAt: Date | null;
+    value: string;
+    minOrderAmount: number | null;
+    maxUses: number | null;
+    usedCount: number;
+}>>;
+export declare const updateCouponCmd: import("@sveltejs/kit").RemoteCommand<{
+    id: string;
+    input: {
+        code?: string | undefined;
+        type?: "fixed" | "percent" | undefined;
+        value?: number | undefined;
+        minOrderAmount?: number | null | undefined;
+        maxUses?: number | null | undefined;
+        expiresAt?: string | null | undefined;
+        isActive?: boolean | undefined;
+    };
+}, Promise<{
+    id: string;
+    code: string;
+    type: import("../../db-postgres/schema/shop/index.js").ShopCouponType;
+    value: string;
+    minOrderAmount: number | null;
+    maxUses: number | null;
+    usedCount: number;
+    expiresAt: Date | null;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}>>;
+export declare const deleteCouponCmd: import("@sveltejs/kit").RemoteCommand<string, Promise<{
+    success: boolean;
+}>>;
+export declare const exportOrdersCsv: import("@sveltejs/kit").RemoteQueryFunction<{
+    status?: "done" | "new" | "awaitingPayment" | "paid" | "preparing" | "sent" | "cancelled" | "paymentRejected" | "refunded" | undefined;
+    email?: string | undefined;
+} | undefined, {
+    csv: string;
+    count: number;
+}>;

package/dist/admin/remote/shop.remote.js

@@ -6,6 +6,10 @@ import { createShippingMethod, deleteShippingMethod, getShippingMethod, listShip
 import { getOrderById, getOrderItems, getOrderStatusHistory, listOrders, updateOrderStatus } from '../../shop/server/orders.js';
 import { cancelShipmentForOrder, createShipmentForOrder } from '../../shop/server/shipments.js';
 import { sendOrderStatusEmail } from '../../shop/server/email.js';
+import { getRefundedAmount, listRefunds, refundOrder, RefundError } from '../../shop/server/refund.js';
+import { getShopDb } from '../../shop/server/db.js';
+import { shopCouponsTable } from '../../db-postgres/schema/shop/index.js';
+import { eq } from 'drizzle-orm';
 import { requireAuth } from './middleware/auth.js';
 export const getShopEnabled = query(async () => {
     return getCMS().shopConfig !== null;
@@ -113,7 +117,8 @@ const orderStatusSchema = z.enum([
     'sent',
     'done',
     'cancelled',
-    'paymentRejected'
+    'paymentRejected',
+    'refunded'
 ]);
 export const listOrdersAdmin = query(z
     .object({
@@ -131,10 +136,7 @@ export const getOrderForAdmin = query(z.string(), async (id) => {
     const order = await getOrderById(id);
     if (!order)
         return null;
-    const [items, history] = await Promise.all([
-        getOrderItems(id),
-        getOrderStatusHistory(id)
-    ]);
+    const [items, history] = await Promise.all([getOrderItems(id), getOrderStatusHistory(id)]);
     return { order, items, history };
 });
 export const updateOrderStatusCmd = command(z.object({
@@ -188,3 +190,157 @@ export const listShopableCollections = query(async () => {
         labels: c.labels
     }));
 });
+// Refunds ────────────────────────────────────────────────────────────────────
+export const getOrderRefundsAdmin = query(z.string(), async (orderId) => {
+    requireAuth();
+    const [refunds, refundedAmount, order] = await Promise.all([
+        listRefunds(orderId),
+        getRefundedAmount(orderId),
+        getOrderById(orderId)
+    ]);
+    if (!order)
+        return null;
+    const shop = getCMS().shopConfig;
+    const adapter = shop?.payment.find((a) => a.id === order.paymentMethod);
+    const refundSupported = !!(adapter && typeof adapter.refund === 'function');
+    return {
+        refunds,
+        refundedAmount,
+        remainingRefundable: Math.max(order.totalGross - refundedAmount, 0),
+        refundSupported,
+        paymentMethod: order.paymentMethod,
+        currency: order.currency,
+        totalGross: order.totalGross
+    };
+});
+export const refundOrderCmd = command(z.object({
+    orderId: z.string(),
+    amount: z.number().int().positive().optional(),
+    reason: z.string().max(500).optional()
+}), async ({ orderId, amount, reason }) => {
+    requireAuth();
+    try {
+        const result = await refundOrder({ orderId, amount, reason, createdBy: 'admin' });
+        return { success: true, ...result };
+    }
+    catch (err) {
+        if (err instanceof RefundError) {
+            return { success: false, code: err.code, error: err.message };
+        }
+        const message = err instanceof Error ? err.message : 'Refund failed';
+        return { success: false, code: 'provider_error', error: message };
+    }
+});
+// Coupons ────────────────────────────────────────────────────────────────────
+const couponInputSchema = z.object({
+    code: z.string().min(1).max(64),
+    type: z.enum(['percent', 'fixed']),
+    value: z.number().nonnegative().max(1e9),
+    minOrderAmount: z.number().int().nonnegative().nullable().optional(),
+    maxUses: z.number().int().positive().nullable().optional(),
+    expiresAt: z.string().datetime().nullable().optional(),
+    isActive: z.boolean().optional()
+});
+export const listCouponsAdmin = query(async () => {
+    requireAuth();
+    const db = getShopDb();
+    return db.select().from(shopCouponsTable).orderBy(shopCouponsTable.createdAt);
+});
+export const getCouponAdmin = query(z.string(), async (id) => {
+    requireAuth();
+    const db = getShopDb();
+    const [row] = await db.select().from(shopCouponsTable).where(eq(shopCouponsTable.id, id));
+    return row ?? null;
+});
+export const createCouponCmd = command(couponInputSchema, async (input) => {
+    requireAuth();
+    const db = getShopDb();
+    const code = input.code.trim().toUpperCase();
+    const [row] = await db
+        .insert(shopCouponsTable)
+        .values({
+        code,
+        type: input.type,
+        value: String(input.value),
+        minOrderAmount: input.minOrderAmount ?? null,
+        maxUses: input.maxUses ?? null,
+        expiresAt: input.expiresAt ? new Date(input.expiresAt) : null,
+        isActive: input.isActive ?? true
+    })
+        .returning();
+    return row;
+});
+export const updateCouponCmd = command(z.object({ id: z.string(), input: couponInputSchema.partial() }), async ({ id, input }) => {
+    requireAuth();
+    const db = getShopDb();
+    const patch = { updatedAt: new Date() };
+    if (input.code !== undefined)
+        patch.code = input.code.trim().toUpperCase();
+    if (input.type !== undefined)
+        patch.type = input.type;
+    if (input.value !== undefined)
+        patch.value = String(input.value);
+    if (input.minOrderAmount !== undefined)
+        patch.minOrderAmount = input.minOrderAmount;
+    if (input.maxUses !== undefined)
+        patch.maxUses = input.maxUses;
+    if (input.expiresAt !== undefined)
+        patch.expiresAt = input.expiresAt ? new Date(input.expiresAt) : null;
+    if (input.isActive !== undefined)
+        patch.isActive = input.isActive;
+    const [row] = await db
+        .update(shopCouponsTable)
+        .set(patch)
+        .where(eq(shopCouponsTable.id, id))
+        .returning();
+    return row;
+});
+export const deleteCouponCmd = command(z.string(), async (id) => {
+    requireAuth();
+    const db = getShopDb();
+    await db.delete(shopCouponsTable).where(eq(shopCouponsTable.id, id));
+    return { success: true };
+});
+// CSV export ─────────────────────────────────────────────────────────────────
+function csvEscape(value) {
+    if (value == null)
+        return '';
+    const s = String(value);
+    if (/[",\n\r]/.test(s))
+        return `"${s.replace(/"/g, '""')}"`;
+    return s;
+}
+const exportFiltersSchema = z
+    .object({
+    status: orderStatusSchema.optional(),
+    email: z.string().optional()
+})
+    .optional();
+export const exportOrdersCsv = query(exportFiltersSchema, async (opts) => {
+    requireAuth();
+    const orders = await listOrders({ ...(opts ?? {}), limit: 10_000 });
+    const header = [
+        'number',
+        'status',
+        'customerEmail',
+        'customerName',
+        'totalGross',
+        'currency',
+        'shippingGross',
+        'paymentMethod',
+        'createdAt'
+    ];
+    const rows = orders.map((o) => [
+        o.number,
+        o.status,
+        o.customerEmail,
+        o.customerName ?? '',
+        (o.totalGross / 100).toFixed(2),
+        o.currency,
+        (o.shippingGross / 100).toFixed(2),
+        o.paymentMethod ?? '',
+        o.createdAt instanceof Date ? o.createdAt.toISOString() : String(o.createdAt)
+    ]);
+    const csv = [header, ...rows].map((row) => row.map(csvEscape).join(',')).join('\r\n');
+    return { csv, count: orders.length };
+});

package/dist/db-postgres/schema/shop/couponRedemptions.d.ts

@@ -0,0 +1,97 @@
+/**
+ * One row per coupon redemption. UNIQUE(orderId) prevents double-charge
+ * accounting if a checkout retries — second redemption for the same order
+ * fails at INSERT, server treats it as already-applied.
+ */
+export declare const shopCouponRedemptionsTable: import("drizzle-orm/pg-core/table", { with: { "resolution-mode": "require" } }).PgTableWithColumns<{
+    name: "shop_coupon_redemptions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "id";
+            tableName: "shop_coupon_redemptions";
+            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;
+        }, {}, {}>;
+        couponId: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "coupon_id";
+            tableName: "shop_coupon_redemptions";
+            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;
+        }, {}, {}>;
+        orderId: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "order_id";
+            tableName: "shop_coupon_redemptions";
+            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;
+        }, {}, {}>;
+        discountAmount: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "discount_amount";
+            tableName: "shop_coupon_redemptions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        redeemedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "redeemed_at";
+            tableName: "shop_coupon_redemptions";
+            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";
+}>;

package/dist/db-postgres/schema/shop/couponRedemptions.js

@@ -0,0 +1,21 @@
+import { integer, pgTable, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { shopCouponsTable } from './coupons.js';
+import { shopOrdersTable } from './order.js';
+/**
+ * One row per coupon redemption. UNIQUE(orderId) prevents double-charge
+ * accounting if a checkout retries — second redemption for the same order
+ * fails at INSERT, server treats it as already-applied.
+ */
+export const shopCouponRedemptionsTable = pgTable('shop_coupon_redemptions', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    couponId: uuid('coupon_id')
+        .notNull()
+        .references(() => shopCouponsTable.id, { onDelete: 'cascade' }),
+    orderId: uuid('order_id')
+        .notNull()
+        .references(() => shopOrdersTable.id, { onDelete: 'cascade' }),
+    discountAmount: integer('discount_amount').notNull(),
+    redeemedAt: timestamp('redeemed_at', { withTimezone: true }).defaultNow().notNull()
+}, (t) => ({
+    orderUnique: uniqueIndex('shop_coupon_redemptions_order_unique').on(t.orderId)
+}));

package/dist/db-postgres/schema/shop/coupons.d.ts

@@ -0,0 +1,197 @@
+export type ShopCouponType = 'percent' | 'fixed';
+export declare const shopCouponsTable: import("drizzle-orm/pg-core/table", { with: { "resolution-mode": "require" } }).PgTableWithColumns<{
+    name: "shop_coupons";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "id";
+            tableName: "shop_coupons";
+            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;
+        }, {}, {}>;
+        code: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "code";
+            tableName: "shop_coupons";
+            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", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "type";
+            tableName: "shop_coupons";
+            dataType: "string";
+            columnType: "PgText";
+            data: ShopCouponType;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ShopCouponType;
+        }>;
+        value: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "value";
+            tableName: "shop_coupons";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        minOrderAmount: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "min_order_amount";
+            tableName: "shop_coupons";
+            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;
+        }, {}, {}>;
+        maxUses: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "max_uses";
+            tableName: "shop_coupons";
+            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;
+        }, {}, {}>;
+        usedCount: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "used_count";
+            tableName: "shop_coupons";
+            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;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "expires_at";
+            tableName: "shop_coupons";
+            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;
+        }, {}, {}>;
+        isActive: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "is_active";
+            tableName: "shop_coupons";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "created_at";
+            tableName: "shop_coupons";
+            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", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "updated_at";
+            tableName: "shop_coupons";
+            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";
+}>;

package/dist/db-postgres/schema/shop/coupons.js

@@ -0,0 +1,18 @@
+import { boolean, integer, numeric, pgTable, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+export const shopCouponsTable = pgTable('shop_coupons', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    // Stored uppercased — user input case-insensitive.
+    code: text('code').notNull(),
+    type: text('type').$type().notNull(),
+    // percent → integer 0-100 stored as numeric for symmetry; fixed → PLN value (precision 20,6 like product.basePrice)
+    value: numeric('value', { precision: 20, scale: 6 }).notNull(),
+    minOrderAmount: integer('min_order_amount'),
+    maxUses: integer('max_uses'),
+    usedCount: integer('used_count').notNull().default(0),
+    expiresAt: timestamp('expires_at', { withTimezone: true }),
+    isActive: boolean('is_active').notNull().default(true),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull()
+}, (t) => ({
+    codeUnique: uniqueIndex('shop_coupons_code_unique').on(t.code)
+}));

package/dist/db-postgres/schema/shop/index.d.ts

@@ -6,3 +6,7 @@ export * from './orderItem.js';
 export * from './orderStatusHistory.js';
 export * from './payment.js';
 export * from './stockReservation.js';
+export * from './refunds.js';
+export * from './webhookEvents.js';
+export * from './coupons.js';
+export * from './couponRedemptions.js';