@rovela-ai/sdk 0.6.0 → 0.7.0

package/dist/core/db/queries.js

@@ -849,6 +849,8 @@ export function periodBounds(periodDays) {
  * selector); omit it for all-time behavior (backward-compatible).
  */
 export async function getRecentOrders(limit = 5, periodDays) {
+    // Full orders SELECT enumerates payment/currency columns — self-heal first.
+    await ensurePaymentMethodsSchemaSafe();
     const db = getDb();
     const where = periodDays != null
         ? (() => {
@@ -1530,8 +1532,11 @@ export async function findCustomerGroups() {
         sortOrder: schema.customerGroups.sortOrder,
         createdAt: schema.customerGroups.createdAt,
         updatedAt: schema.customerGroups.updatedAt,
+        // Plain identifier (not a drizzle column interpolation): inside a raw
+        // correlated subquery the interpolated form mis-renders and the count
+        // silently returns 0. Outer table is unaliased `customer_groups`.
         customerCount: sql `(
-        SELECT count(*)::int FROM customers c WHERE c.group_id = ${schema.customerGroups.id}
+        SELECT count(*)::int FROM customers c WHERE c.group_id = customer_groups.id
       )`,
     })
         .from(schema.customerGroups)
@@ -1642,6 +1647,9 @@ export async function ensurePaymentMethodsSchema() {
         await db.execute(sql `ALTER TABLE orders ADD COLUMN IF NOT EXISTS payment_provider varchar(20) NOT NULL DEFAULT 'stripe'`);
         await db.execute(sql `ALTER TABLE orders ADD COLUMN IF NOT EXISTS payment_method_id uuid`);
         await db.execute(sql `ALTER TABLE orders ADD COLUMN IF NOT EXISTS payment_method_label varchar(100)`);
+        // Per-order currency snapshot (SDK 0.7.0 — pricing core). Rides this
+        // ensure because it already covers every order read/write chokepoint.
+        await db.execute(sql `ALTER TABLE orders ADD COLUMN IF NOT EXISTS currency varchar(3)`);
         paymentMethodsSchemaEnsured = true;
     }
     catch (err) {
@@ -1740,6 +1748,256 @@ export async function deletePaymentMethod(id) {
     return deleted.length > 0;
 }
 // =============================================================================
+// Discounts (native engine — see schema.ts for the rule model)
+// =============================================================================
+let discountsSchemaEnsured = false;
+/**
+ * Self-heal the discounts schema on stores provisioned before the native
+ * discounts engine (SDK 0.7.0). Idempotent + module-cached; called at every
+ * discount read/write chokepoint.
+ */
+export async function ensureDiscountsSchema() {
+    if (discountsSchemaEnsured)
+        return;
+    const db = getDb();
+    try {
+        await db.execute(sql `
+      CREATE TABLE IF NOT EXISTS discounts (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        method varchar(20) NOT NULL DEFAULT 'code',
+        code varchar(64),
+        title varchar(255) NOT NULL,
+        type varchar(20) NOT NULL,
+        value decimal(10,2) NOT NULL DEFAULT '0',
+        applies_to varchar(20) NOT NULL DEFAULT 'order',
+        target_ids jsonb NOT NULL DEFAULT '[]'::jsonb,
+        min_subtotal decimal(10,2),
+        min_quantity integer,
+        eligibility varchar(20) NOT NULL DEFAULT 'all',
+        group_ids jsonb NOT NULL DEFAULT '[]'::jsonb,
+        usage_limit integer,
+        once_per_customer boolean NOT NULL DEFAULT false,
+        used_count integer NOT NULL DEFAULT 0,
+        combines_with jsonb NOT NULL DEFAULT '{}'::jsonb,
+        bxgy jsonb,
+        starts_at timestamp,
+        ends_at timestamp,
+        enabled boolean NOT NULL DEFAULT true,
+        sort_order integer NOT NULL DEFAULT 0,
+        created_at timestamp NOT NULL DEFAULT now(),
+        updated_at timestamp NOT NULL DEFAULT now()
+      )
+    `);
+        await db.execute(sql `CREATE INDEX IF NOT EXISTS discounts_code_idx ON discounts (code)`);
+        await db.execute(sql `CREATE INDEX IF NOT EXISTS discounts_enabled_idx ON discounts (enabled)`);
+        await db.execute(sql `CREATE INDEX IF NOT EXISTS discounts_method_idx ON discounts (method)`);
+        // Case-insensitive code uniqueness (codes are stored UPPERCASE; the
+        // partial unique index is belt + suspenders against write-path drift).
+        await db.execute(sql `CREATE UNIQUE INDEX IF NOT EXISTS discounts_code_unique_idx
+          ON discounts (upper(code)) WHERE code IS NOT NULL`);
+        await db.execute(sql `
+      CREATE TABLE IF NOT EXISTS discount_redemptions (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        discount_id uuid NOT NULL,
+        order_id uuid NOT NULL,
+        customer_id uuid,
+        email varchar(255),
+        amount decimal(10,2) NOT NULL DEFAULT '0',
+        created_at timestamp NOT NULL DEFAULT now()
+      )
+    `);
+        await db.execute(sql `CREATE INDEX IF NOT EXISTS discount_redemptions_discount_idx ON discount_redemptions (discount_id)`);
+        await db.execute(sql `CREATE INDEX IF NOT EXISTS discount_redemptions_customer_idx ON discount_redemptions (discount_id, customer_id)`);
+        await db.execute(sql `CREATE INDEX IF NOT EXISTS discount_redemptions_email_idx ON discount_redemptions (discount_id, email)`);
+        await db.execute(sql `CREATE INDEX IF NOT EXISTS discount_redemptions_order_idx ON discount_redemptions (order_id)`);
+        discountsSchemaEnsured = true;
+    }
+    catch (err) {
+        console.error('[ensureDiscountsSchema] migration failed:', err);
+        throw err;
+    }
+}
+/** Best-effort variant — never throws (checkout must not 500 on a migration hiccup). */
+export async function ensureDiscountsSchemaSafe() {
+    try {
+        await ensureDiscountsSchema();
+    }
+    catch {
+        // logged inside ensureDiscountsSchema
+    }
+}
+/** All discounts, admin view (sorted). */
+export async function findDiscounts() {
+    await ensureDiscountsSchema();
+    const db = getDb();
+    return db
+        .select()
+        .from(schema.discounts)
+        .orderBy(asc(schema.discounts.sortOrder), desc(schema.discounts.createdAt));
+}
+export async function findDiscountById(id) {
+    await ensureDiscountsSchema();
+    const db = getDb();
+    const rows = await db
+        .select()
+        .from(schema.discounts)
+        .where(eq(schema.discounts.id, id))
+        .limit(1);
+    return rows[0] ?? null;
+}
+/** Enabled code discount by (case-insensitive) code — checkout entry point. */
+export async function findDiscountByCode(code) {
+    await ensureDiscountsSchemaSafe();
+    const db = getDb();
+    const normalized = code.trim().toUpperCase();
+    if (!normalized)
+        return null;
+    const rows = await db
+        .select()
+        .from(schema.discounts)
+        .where(and(eq(schema.discounts.method, 'code'), sql `upper(${schema.discounts.code}) = ${normalized}`))
+        .limit(1);
+    return rows[0] ?? null;
+}
+/** Enabled automatic discounts — always evaluated at checkout. */
+export async function findActiveAutomaticDiscounts() {
+    await ensureDiscountsSchemaSafe();
+    const db = getDb();
+    return db
+        .select()
+        .from(schema.discounts)
+        .where(and(eq(schema.discounts.method, 'automatic'), eq(schema.discounts.enabled, true)))
+        .orderBy(asc(schema.discounts.sortOrder), asc(schema.discounts.createdAt));
+}
+export async function createDiscount(data) {
+    await ensureDiscountsSchema();
+    const db = getDb();
+    const [row] = await db
+        .insert(schema.discounts)
+        .values({
+        method: data.method ?? 'code',
+        code: data.code ? data.code.trim().toUpperCase() : null,
+        title: data.title,
+        type: data.type,
+        value: String(data.value ?? 0),
+        appliesTo: data.appliesTo ?? 'order',
+        targetIds: data.targetIds ?? [],
+        minSubtotal: data.minSubtotal != null ? String(data.minSubtotal) : null,
+        minQuantity: data.minQuantity ?? null,
+        eligibility: data.eligibility ?? 'all',
+        groupIds: data.groupIds ?? [],
+        usageLimit: data.usageLimit ?? null,
+        oncePerCustomer: data.oncePerCustomer ?? false,
+        combinesWith: data.combinesWith ?? {},
+        bxgy: data.bxgy ?? null,
+        startsAt: data.startsAt ?? null,
+        endsAt: data.endsAt ?? null,
+        enabled: data.enabled ?? true,
+        sortOrder: data.sortOrder ?? 0,
+    })
+        .returning();
+    return row;
+}
+export async function updateDiscount(id, data) {
+    await ensureDiscountsSchema();
+    const db = getDb();
+    const [row] = await db
+        .update(schema.discounts)
+        .set({
+        ...(data.method !== undefined && { method: data.method }),
+        ...(data.code !== undefined && {
+            code: data.code ? data.code.trim().toUpperCase() : null,
+        }),
+        ...(data.title !== undefined && { title: data.title }),
+        ...(data.type !== undefined && { type: data.type }),
+        ...(data.value !== undefined && { value: String(data.value ?? 0) }),
+        ...(data.appliesTo !== undefined && { appliesTo: data.appliesTo }),
+        ...(data.targetIds !== undefined && { targetIds: data.targetIds ?? [] }),
+        ...(data.minSubtotal !== undefined && {
+            minSubtotal: data.minSubtotal != null ? String(data.minSubtotal) : null,
+        }),
+        ...(data.minQuantity !== undefined && { minQuantity: data.minQuantity ?? null }),
+        ...(data.eligibility !== undefined && { eligibility: data.eligibility }),
+        ...(data.groupIds !== undefined && { groupIds: data.groupIds ?? [] }),
+        ...(data.usageLimit !== undefined && { usageLimit: data.usageLimit ?? null }),
+        ...(data.oncePerCustomer !== undefined && { oncePerCustomer: data.oncePerCustomer }),
+        ...(data.combinesWith !== undefined && { combinesWith: data.combinesWith ?? {} }),
+        ...(data.bxgy !== undefined && { bxgy: data.bxgy ?? null }),
+        ...(data.startsAt !== undefined && { startsAt: data.startsAt ?? null }),
+        ...(data.endsAt !== undefined && { endsAt: data.endsAt ?? null }),
+        ...(data.enabled !== undefined && { enabled: data.enabled }),
+        ...(data.sortOrder !== undefined && { sortOrder: data.sortOrder }),
+        updatedAt: new Date(),
+    })
+        .where(eq(schema.discounts.id, id))
+        .returning();
+    return row ?? null;
+}
+/**
+ * Hard delete. Redemption history survives (soft refs) so past orders keep
+ * their recorded discount code + amount snapshots.
+ */
+export async function deleteDiscount(id) {
+    await ensureDiscountsSchema();
+    const db = getDb();
+    const deleted = await db
+        .delete(schema.discounts)
+        .where(eq(schema.discounts.id, id))
+        .returning({ id: schema.discounts.id });
+    return deleted.length > 0;
+}
+/**
+ * Prior redemptions by this customer (id OR email) — powers oncePerCustomer.
+ */
+export async function countDiscountRedemptionsForCustomer(discountId, customer) {
+    await ensureDiscountsSchemaSafe();
+    const db = getDb();
+    const conditions = [];
+    if (customer.customerId) {
+        conditions.push(eq(schema.discountRedemptions.customerId, customer.customerId));
+    }
+    if (customer.email) {
+        conditions.push(sql `lower(${schema.discountRedemptions.email}) = ${customer.email.toLowerCase()}`);
+    }
+    if (conditions.length === 0)
+        return 0;
+    const rows = await db
+        .select({ count: sql `count(*)` })
+        .from(schema.discountRedemptions)
+        .where(and(eq(schema.discountRedemptions.discountId, discountId), or(...conditions)));
+    return Number(rows[0]?.count || 0);
+}
+/**
+ * Atomically claim one use of a discount (usage-limit guard) and record the
+ * redemption. Returns false when the limit was exhausted between evaluation
+ * and order creation — the order still stands (the race window is seconds);
+ * the claim failure is logged for reconciliation.
+ */
+export async function recordDiscountRedemption(params) {
+    await ensureDiscountsSchemaSafe();
+    const db = getDb();
+    const claimed = await db.execute(sql `
+    UPDATE discounts
+    SET used_count = used_count + 1, updated_at = now()
+    WHERE id = ${params.discountId}
+      AND (usage_limit IS NULL OR used_count < usage_limit)
+    RETURNING id
+  `);
+    const claimedRows = claimed.rows ?? [];
+    const ok = Array.isArray(claimedRows) ? claimedRows.length > 0 : false;
+    await db.insert(schema.discountRedemptions).values({
+        discountId: params.discountId,
+        orderId: params.orderId,
+        customerId: params.customerId ?? null,
+        email: params.email ? params.email.toLowerCase() : null,
+        amount: (params.amountCents / 100).toFixed(2),
+    });
+    if (!ok) {
+        console.warn('[Discounts] usage-limit claim failed post-order (limit hit in the race window):', params.discountId, 'order:', params.orderId);
+    }
+    return ok;
+}
+// =============================================================================
 // Order Queries (for admin module)
 // =============================================================================
 /**
@@ -1829,12 +2087,50 @@ export async function getOrdersByStatus(periodDays) {
         count: Number(r.count),
     }));
 }
+/**
+ * Self-heal for store_settings columns added after a store's branch was
+ * created (drizzle `.select()` enumerates every schema column, so a missing
+ * column breaks ALL settings reads). Idempotent; cached in-process. Called
+ * best-effort at the top of findSettings/upsertSettings — the settings
+ * chokepoints every surface goes through.
+ *
+ * Columns owned here:
+ * - store_country varchar(2) — SDK 0.7.0 (store-country single source of truth)
+ */
+let storeSettingsSchemaEnsured = false;
+export async function ensureStoreSettingsSchema() {
+    if (storeSettingsSchemaEnsured)
+        return;
+    const db = getDb();
+    try {
+        await db.execute(sql `
+      ALTER TABLE store_settings
+      ADD COLUMN IF NOT EXISTS store_country varchar(2)
+    `);
+        storeSettingsSchemaEnsured = true;
+    }
+    catch (err) {
+        // Don't poison the cache on transient failures — retry next call.
+        console.error('[ensureStoreSettingsSchema] migration failed:', err);
+        throw err;
+    }
+}
+/** Best-effort variant — never throws (the subsequent read surfaces real errors). */
+export async function ensureStoreSettingsSchemaSafe() {
+    try {
+        await ensureStoreSettingsSchema();
+    }
+    catch {
+        // logged inside ensureStoreSettingsSchema
+    }
+}
 /**
  * Find store settings.
  * Returns null if no settings exist (first time access).
  * Each store has only one settings row.
  */
 export async function findSettings() {
+    await ensureStoreSettingsSchemaSafe();
     const db = getDb();
     const [settings] = await db
         .select()
@@ -1848,6 +2144,7 @@ export async function findSettings() {
         logoUrl: settings.logoUrl,
         storeCurrency: settings.storeCurrency,
         storeTimezone: settings.storeTimezone,
+        storeCountry: settings.storeCountry,
         taxIncludedInPrices: settings.taxIncludedInPrices,
         shippingEnabled: settings.shippingEnabled,
         freeShippingThreshold: settings.freeShippingThreshold
@@ -1902,6 +2199,7 @@ export async function listMetafieldKeys() {
  * Each store has only one settings row.
  */
 export async function upsertSettings(data) {
+    await ensureStoreSettingsSchemaSafe();
     const db = getDb();
     // Check if settings exist
     const existing = await db
@@ -1914,6 +2212,7 @@ export async function upsertSettings(data) {
         logoUrl: data.logoUrl ?? undefined,
         storeCurrency: data.storeCurrency ?? undefined,
         storeTimezone: data.storeTimezone ?? undefined,
+        storeCountry: data.storeCountry ?? undefined,
         taxIncludedInPrices: data.taxIncludedInPrices ?? undefined,
         shippingEnabled: data.shippingEnabled ?? undefined,
         freeShippingThreshold: data.freeShippingThreshold !== null && data.freeShippingThreshold !== undefined
@@ -1959,6 +2258,7 @@ export async function upsertSettings(data) {
         logoUrl: result.logoUrl,
         storeCurrency: result.storeCurrency,
         storeTimezone: result.storeTimezone,
+        storeCountry: result.storeCountry,
         taxIncludedInPrices: result.taxIncludedInPrices,
         shippingEnabled: result.shippingEnabled,
         freeShippingThreshold: result.freeShippingThreshold