includio-cms 0.24.0 → 0.25.0

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

@@ -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';

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

@@ -104,6 +104,23 @@ export declare const shopProductsTable: import("drizzle-orm/pg-core/table", { wi
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        lowStockThreshold: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "low_stock_threshold";
+            tableName: "shop_products";
+            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;
+        }, {}, {}>;
         createdAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
             name: "created_at";
             tableName: "shop_products";

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

@@ -11,6 +11,8 @@ export const shopProductsTable = pgTable('shop_products', {
     vatRate: integer('vat_rate').notNull(),
     isActive: boolean('is_active').default(true).notNull(),
     sortOrder: integer('sort_order'),
+    // Null = alert disabled. When stock decrement crosses threshold, fire-and-forget admin email.
+    lowStockThreshold: integer('low_stock_threshold'),
     createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
     updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull()
 });

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

@@ -0,0 +1,214 @@
+export type ShopRefundStatus = 'pending' | 'succeeded' | 'failed';
+export declare const shopRefundsTable: import("drizzle-orm/pg-core/table", { with: { "resolution-mode": "require" } }).PgTableWithColumns<{
+    name: "shop_refunds";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "id";
+            tableName: "shop_refunds";
+            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;
+        }, {}, {}>;
+        orderId: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "order_id";
+            tableName: "shop_refunds";
+            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;
+        }, {}, {}>;
+        paymentId: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "payment_id";
+            tableName: "shop_refunds";
+            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;
+        }, {}, {}>;
+        provider: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "provider";
+            tableName: "shop_refunds";
+            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;
+        }, {}, {}>;
+        providerRef: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "provider_ref";
+            tableName: "shop_refunds";
+            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;
+        }, {}, {}>;
+        amount: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "amount";
+            tableName: "shop_refunds";
+            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;
+        }, {}, {}>;
+        currency: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "currency";
+            tableName: "shop_refunds";
+            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;
+        }, {}, {}>;
+        reason: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "reason";
+            tableName: "shop_refunds";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "status";
+            tableName: "shop_refunds";
+            dataType: "string";
+            columnType: "PgText";
+            data: ShopRefundStatus;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ShopRefundStatus;
+        }>;
+        createdBy: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "created_by";
+            tableName: "shop_refunds";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "created_at";
+            tableName: "shop_refunds";
+            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_refunds";
+            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/refunds.js

@@ -0,0 +1,21 @@
+import { integer, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { shopOrdersTable } from './order.js';
+import { shopPaymentsTable } from './payment.js';
+export const shopRefundsTable = pgTable('shop_refunds', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    orderId: uuid('order_id')
+        .notNull()
+        .references(() => shopOrdersTable.id, { onDelete: 'cascade' }),
+    paymentId: uuid('payment_id').references(() => shopPaymentsTable.id, {
+        onDelete: 'set null'
+    }),
+    provider: text('provider').notNull(),
+    providerRef: text('provider_ref'),
+    amount: integer('amount').notNull(),
+    currency: text('currency').notNull(),
+    reason: text('reason'),
+    status: text('status').$type().notNull().default('pending'),
+    createdBy: text('created_by'),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull()
+});

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

@@ -0,0 +1,183 @@
+/**
+ * Persistent webhook idempotency log. One row per unique (provider, eventId).
+ * Inserted before processing — `processedAt` set after success. Race-safe via
+ * UNIQUE constraint: concurrent duplicate events fail at INSERT, second caller
+ * returns idempotent response without re-processing.
+ */
+export declare const shopWebhookEventsTable: import("drizzle-orm/pg-core/table", { with: { "resolution-mode": "require" } }).PgTableWithColumns<{
+    name: "shop_webhook_events";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "id";
+            tableName: "shop_webhook_events";
+            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;
+        }, {}, {}>;
+        provider: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "provider";
+            tableName: "shop_webhook_events";
+            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;
+        }, {}, {}>;
+        eventId: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "event_id";
+            tableName: "shop_webhook_events";
+            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;
+        }, {}, {}>;
+        eventType: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "event_type";
+            tableName: "shop_webhook_events";
+            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;
+        }, {}, {}>;
+        orderId: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "order_id";
+            tableName: "shop_webhook_events";
+            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;
+        }, {}, {}>;
+        orderNumber: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "order_number";
+            tableName: "shop_webhook_events";
+            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;
+        }, {}, {}>;
+        payloadHash: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "payload_hash";
+            tableName: "shop_webhook_events";
+            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;
+        }, {}, {}>;
+        raw: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "raw";
+            tableName: "shop_webhook_events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        receivedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "received_at";
+            tableName: "shop_webhook_events";
+            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;
+        }, {}, {}>;
+        processedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "processed_at";
+            tableName: "shop_webhook_events";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

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

@@ -0,0 +1,22 @@
+import { jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { shopOrdersTable } from './order.js';
+/**
+ * Persistent webhook idempotency log. One row per unique (provider, eventId).
+ * Inserted before processing — `processedAt` set after success. Race-safe via
+ * UNIQUE constraint: concurrent duplicate events fail at INSERT, second caller
+ * returns idempotent response without re-processing.
+ */
+export const shopWebhookEventsTable = pgTable('shop_webhook_events', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    provider: text('provider').notNull(),
+    eventId: text('event_id').notNull(),
+    eventType: text('event_type'),
+    orderId: uuid('order_id').references(() => shopOrdersTable.id, { onDelete: 'set null' }),
+    orderNumber: text('order_number'),
+    payloadHash: text('payload_hash'),
+    raw: jsonb('raw'),
+    receivedAt: timestamp('received_at', { withTimezone: true }).defaultNow().notNull(),
+    processedAt: timestamp('processed_at', { withTimezone: true })
+}, (t) => ({
+    providerEventUnique: uniqueIndex('shop_webhook_events_provider_event_unique').on(t.provider, t.eventId)
+}));

package/dist/shop/adapters/payu/client.d.ts

@@ -19,4 +19,13 @@ export declare class PayuClient {
         orderId: string;
     }>;
     getOrder(payuOrderId: string): Promise<unknown>;
+    refundOrder(payuOrderId: string, input: {
+        description: string;
+        amount?: number;
+        currencyCode?: string;
+    }): Promise<{
+        refundId: string;
+        status: string;
+        raw: unknown;
+    }>;
 }

package/dist/shop/adapters/payu/client.js

@@ -75,4 +75,33 @@ export class PayuClient {
             throw new Error(`PayU getOrder failed: ${res.status}`);
         return res.json();
     }
+    async refundOrder(payuOrderId, input) {
+        const token = await this.getAccessToken();
+        const refund = {
+            description: input.description.slice(0, 70)
+        };
+        if (input.amount !== undefined) {
+            refund.amount = input.amount;
+            if (input.currencyCode)
+                refund.currencyCode = input.currencyCode;
+        }
+        const res = await this.fetchImpl(`${this.base}/api/v2_1/orders/${encodeURIComponent(payuOrderId)}/refunds`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+            },
+            body: JSON.stringify({ refund })
+        });
+        if (!res.ok)
+            throw new Error(`PayU refundOrder failed: ${res.status}`);
+        const data = (await res.json());
+        if (data.status?.statusCode && data.status.statusCode !== 'SUCCESS') {
+            throw new Error(`PayU refund status ${data.status.statusCode}${data.status.statusDesc ? ` — ${data.status.statusDesc}` : ''}`);
+        }
+        const refundId = data.refund?.refundId ?? '';
+        const status = data.refund?.status ?? 'PENDING';
+        return { refundId, status, raw: data };
+    }
 }

package/dist/shop/adapters/payu/index.js

@@ -77,11 +77,27 @@ export function payuAdapter(opts) {
             const status = parsed.order?.status ?? 'PENDING';
             if (!extOrderId)
                 throw new Error('PayU webhook missing extOrderId');
+            // PayU sends a `notify_id` in the `properties` array — use it for idempotency.
+            const notifyId = parsed.properties?.find((p) => p.name === 'PAYMENT_ID' || p.name === 'TRANSACTION_ID' || p.name === 'NOTIFY_ID')?.value;
             return {
                 orderNumber: extOrderId,
                 status: mapPayuStatus(status),
                 providerRef: payuOrderId,
-                raw: parsed
+                raw: parsed,
+                eventId: notifyId ? `${payuOrderId}:${status}:${notifyId}` : `${payuOrderId}:${status}`,
+                eventType: status
+            };
+        },
+        async refund(input) {
+            const result = await client.refundOrder(input.providerRef, {
+                description: input.reason ?? 'Refund',
+                amount: input.amount,
+                currencyCode: input.currency
+            });
+            return {
+                providerRef: result.refundId,
+                amount: input.amount ?? 0,
+                raw: result.raw
             };
         }
     };

package/dist/shop/adapters/stripe/index.d.ts

@@ -0,0 +1,64 @@
+import type { I18nText, PaymentAdapter } from '../../types.js';
+type StripeNs = typeof import('stripe');
+export interface StripeAdapterOptions {
+    /**
+     * Stripe secret key (`sk_live_…` / `sk_test_…`). Required.
+     */
+    secretKey: string;
+    /**
+     * Webhook signing secret (`whsec_…`) issued by Stripe per endpoint.
+     * Used by `handleWebhook()` to verify the `Stripe-Signature` header.
+     */
+    webhookSecret: string;
+    /**
+     * Absolute URL template the customer is redirected to after a successful
+     * payment. Supports `{orderNumber}`, `{orderId}`, `{accessToken}`, `{language}`.
+     * If omitted, falls back to `shop.orderViewUrl` (must then be absolute).
+     */
+    successUrl?: string;
+    /**
+     * Absolute URL the customer is redirected to if they cancel. If omitted,
+     * falls back to `shop.orderViewUrl` (same as `successUrl`).
+     */
+    cancelUrl?: string;
+    /**
+     * Stripe API version. Defaults to a recent stable release. Override only
+     * if your account is pinned to a different one.
+     */
+    apiVersion?: string;
+    /**
+     * Display name for the synthesised line item shown on the Stripe receipt.
+     * Default: `Order {number}` per language fallback (PL primary).
+     */
+    productName?: I18nText;
+    id?: string;
+    label?: I18nText;
+    /**
+     * Override the lazy import — primarily for testing. When provided, replaces
+     * `await import('stripe')`. Production code should leave this unset.
+     */
+    stripeImport?: () => Promise<StripeNs>;
+}
+/**
+ * Stripe payment adapter (Checkout Session flow).
+ *
+ * `stripe` is an **optional peer dependency** — install it in your project
+ * (`pnpm add stripe`) when using this adapter. The SDK is lazy-loaded on first
+ * `createPayment()` / `getStatus()` / `refund()` / `handleWebhook()` call;
+ * a missing peer throws a clear error.
+ *
+ * @public
+ * @example
+ * ```ts
+ * import { stripeAdapter } from 'includio-cms/shop';
+ *
+ * const stripe = stripeAdapter({
+ *   secretKey: process.env.STRIPE_SECRET_KEY!,
+ *   webhookSecret: process.env.STRIPE_WEBHOOK_SECRET!,
+ *   successUrl: 'https://example.com/shop/order/{orderNumber}?token={accessToken}',
+ *   cancelUrl: 'https://example.com/shop/cancelled'
+ * });
+ * ```
+ */
+export declare function stripeAdapter(opts: StripeAdapterOptions): PaymentAdapter;
+export {};