@rovela-ai/sdk 0.5.17 → 0.6.1

package/dist/core/db/queries.js

@@ -387,6 +387,8 @@ export async function findCategoryBySlug(slug) {
  * Find orders with filtering and pagination
  */
 export async function findOrders(options = {}) {
+    // orders SELECT enumerates the payment columns — self-heal older stores first.
+    await ensurePaymentMethodsSchemaSafe();
     const db = getDb();
     const conditions = [];
     if (options.status) {
@@ -412,6 +414,8 @@ export async function findOrders(options = {}) {
  * Find order by ID with items (includes product images)
  */
 export async function findOrderById(id) {
+    // orders SELECT enumerates the payment columns — self-heal older stores first.
+    await ensurePaymentMethodsSchemaSafe();
     const db = getDb();
     const order = await db
         .select()
@@ -520,6 +524,8 @@ export async function findOrCreateGuestCustomer(email, name) {
  * Find customer by email
  */
 export async function findCustomerByEmail(email) {
+    // SELECT enumerates customers.group_id — self-heal older stores first.
+    await ensureCustomerGroupsSchemaSafe();
     const db = getDb();
     const result = await db
         .select()
@@ -532,6 +538,8 @@ export async function findCustomerByEmail(email) {
  * Find customer by ID
  */
 export async function findCustomerById(id) {
+    // SELECT enumerates customers.group_id — self-heal older stores first.
+    await ensureCustomerGroupsSchemaSafe();
     const db = getDb();
     const result = await db
         .select()
@@ -544,10 +552,15 @@ export async function findCustomerById(id) {
  * Find all customers with pagination
  */
 export async function findCustomers(options = {}) {
+    // SELECT enumerates customers.group_id — self-heal older stores first.
+    await ensureCustomerGroupsSchemaSafe();
     const db = getDb();
     const conditions = [];
     if (options.search) {
-        conditions.push(ilike(schema.customers.email, `%${options.search}%`));
+        conditions.push(or(ilike(schema.customers.email, `%${options.search}%`), ilike(schema.customers.name, `%${options.search}%`)));
+    }
+    if (options.groupId) {
+        conditions.push(eq(schema.customers.groupId, options.groupId));
     }
     const query = db
         .select()
@@ -857,6 +870,8 @@ export async function getRecentOrders(limit = 5, periodDays) {
  * Create a new order
  */
 export async function createOrder(data) {
+    // orders SELECT enumerates the payment columns — self-heal older stores first.
+    await ensurePaymentMethodsSchemaSafe();
     const db = getDb();
     const [order] = await db
         .insert(schema.orders)
@@ -906,6 +921,8 @@ export async function updateOrderShipping(orderId, shippingData) {
  * Used for idempotency in webhook handling
  */
 export async function findOrderByPaymentIntent(paymentIntentId) {
+    // orders SELECT enumerates the payment columns — self-heal older stores first.
+    await ensurePaymentMethodsSchemaSafe();
     const db = getDb();
     const [order] = await db
         .select()
@@ -1153,10 +1170,14 @@ export async function countCategories() {
  * Count customers with optional search
  */
 export async function countCustomers(options = {}) {
+    await ensureCustomerGroupsSchemaSafe();
     const db = getDb();
     const conditions = [];
     if (options.search) {
-        conditions.push(ilike(schema.customers.email, `%${options.search}%`));
+        conditions.push(or(ilike(schema.customers.email, `%${options.search}%`), ilike(schema.customers.name, `%${options.search}%`)));
+    }
+    if (options.groupId) {
+        conditions.push(eq(schema.customers.groupId, options.groupId));
     }
     const result = await db
         .select({ count: sql `count(*)` })
@@ -1168,6 +1189,8 @@ export async function countCustomers(options = {}) {
  * Find orders for a specific customer
  */
 export async function findCustomerOrders(customerId) {
+    // orders SELECT enumerates the payment columns — self-heal older stores first.
+    await ensurePaymentMethodsSchemaSafe();
     const db = getDb();
     return db
         .select()
@@ -1445,6 +1468,281 @@ export async function setDefaultCustomerAddress(id, customerId, kind) {
     return true;
 }
 // =============================================================================
+// Customer Groups (merchant-defined customer types)
+// =============================================================================
+let customerGroupsSchemaEnsured = false;
+/**
+ * Self-heal the customer-groups schema on stores provisioned before this
+ * feature. New stores get it from schema.ts at branch creation. Idempotent +
+ * module-cached (mirrors ensureCustomerAddressSchema). ALSO guards the
+ * `customers.group_id` column that every `customers` SELECT now enumerates —
+ * called (best-effort) from the customer read chokepoints so an SDK upgrade
+ * self-migrates instead of breaking reads.
+ */
+export async function ensureCustomerGroupsSchema() {
+    if (customerGroupsSchemaEnsured)
+        return;
+    const db = getDb();
+    try {
+        await db.execute(sql `ALTER TABLE customers ADD COLUMN IF NOT EXISTS group_id uuid`);
+        await db.execute(sql `CREATE INDEX IF NOT EXISTS customers_group_id_idx ON customers (group_id)`);
+        await db.execute(sql `
+      CREATE TABLE IF NOT EXISTS customer_groups (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        name varchar(100) NOT NULL,
+        description varchar(255),
+        is_active 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 customer_groups_sort_order_idx ON customer_groups (sort_order)`);
+        customerGroupsSchemaEnsured = true;
+    }
+    catch (err) {
+        console.error('[ensureCustomerGroupsSchema] migration failed:', err);
+        throw err;
+    }
+}
+/** Best-effort variant for hot read paths (login, listings): a transient
+ *  ensure failure must not block the read — if the schema truly is missing,
+ *  the subsequent SELECT fails with a clear error anyway. Exported for the
+ *  customer-service read paths that select customers.* directly. */
+export async function ensureCustomerGroupsSchemaSafe() {
+    try {
+        await ensureCustomerGroupsSchema();
+    }
+    catch {
+        // logged inside ensureCustomerGroupsSchema
+    }
+}
+/** List all groups (sorted), each with its live member count. */
+export async function findCustomerGroups() {
+    await ensureCustomerGroupsSchema();
+    const db = getDb();
+    return db
+        .select({
+        id: schema.customerGroups.id,
+        name: schema.customerGroups.name,
+        description: schema.customerGroups.description,
+        isActive: schema.customerGroups.isActive,
+        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 = customer_groups.id
+      )`,
+    })
+        .from(schema.customerGroups)
+        .orderBy(asc(schema.customerGroups.sortOrder), asc(schema.customerGroups.createdAt));
+}
+export async function findCustomerGroupById(id) {
+    await ensureCustomerGroupsSchema();
+    const db = getDb();
+    const rows = await db
+        .select()
+        .from(schema.customerGroups)
+        .where(eq(schema.customerGroups.id, id))
+        .limit(1);
+    return rows[0] ?? null;
+}
+export async function createCustomerGroup(data) {
+    await ensureCustomerGroupsSchema();
+    const db = getDb();
+    const [group] = await db
+        .insert(schema.customerGroups)
+        .values({
+        name: data.name,
+        description: data.description ?? null,
+        isActive: data.isActive ?? true,
+        sortOrder: data.sortOrder ?? 0,
+    })
+        .returning();
+    return group;
+}
+export async function updateCustomerGroup(id, data) {
+    await ensureCustomerGroupsSchema();
+    const db = getDb();
+    const set = { updatedAt: new Date() };
+    if (data.name !== undefined)
+        set.name = data.name;
+    if (data.description !== undefined)
+        set.description = data.description ?? null;
+    if (data.isActive !== undefined)
+        set.isActive = data.isActive;
+    if (data.sortOrder !== undefined)
+        set.sortOrder = data.sortOrder;
+    const [group] = await db
+        .update(schema.customerGroups)
+        .set(set)
+        .where(eq(schema.customerGroups.id, id))
+        .returning();
+    return group ?? null;
+}
+/**
+ * Delete a group. Members are UNGROUPED (group_id set to null) first — there
+ * is no hard FK, so the unset is explicit here to avoid dangling references.
+ */
+export async function deleteCustomerGroup(id) {
+    await ensureCustomerGroupsSchema();
+    const db = getDb();
+    await db
+        .update(schema.customers)
+        .set({ groupId: null })
+        .where(eq(schema.customers.groupId, id));
+    const deleted = await db
+        .delete(schema.customerGroups)
+        .where(eq(schema.customerGroups.id, id))
+        .returning({ id: schema.customerGroups.id });
+    return deleted.length > 0;
+}
+/** Assign (or unassign with null) a customer's group. Caller validates the group id. */
+export async function setCustomerGroup(customerId, groupId) {
+    await ensureCustomerGroupsSchema();
+    const db = getDb();
+    const [customer] = await db
+        .update(schema.customers)
+        .set({ groupId, updatedAt: new Date() })
+        .where(eq(schema.customers.id, customerId))
+        .returning();
+    return customer ?? null;
+}
+// =============================================================================
+// Payment Methods (merchant-managed payment options beyond native Stripe)
+// =============================================================================
+let paymentMethodsSchemaEnsured = false;
+/**
+ * Self-heal the payment-methods schema on stores provisioned before this
+ * feature: the payment_methods table + the orders payment columns that every
+ * `orders` SELECT now enumerates. `payment_provider` matches the PayPal
+ * feature card's lazy column EXACTLY so both converge idempotently.
+ * Idempotent + module-cached.
+ */
+export async function ensurePaymentMethodsSchema() {
+    if (paymentMethodsSchemaEnsured)
+        return;
+    const db = getDb();
+    try {
+        await db.execute(sql `
+      CREATE TABLE IF NOT EXISTS payment_methods (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        kind varchar(20) NOT NULL DEFAULT 'manual',
+        name varchar(100) NOT NULL,
+        instructions text,
+        enabled boolean NOT NULL DEFAULT true,
+        sort_order integer NOT NULL DEFAULT 0,
+        config jsonb NOT NULL DEFAULT '{}'::jsonb,
+        created_at timestamp NOT NULL DEFAULT now(),
+        updated_at timestamp NOT NULL DEFAULT now()
+      )
+    `);
+        await db.execute(sql `CREATE INDEX IF NOT EXISTS payment_methods_enabled_idx ON payment_methods (enabled)`);
+        await db.execute(sql `CREATE INDEX IF NOT EXISTS payment_methods_sort_order_idx ON payment_methods (sort_order)`);
+        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)`);
+        paymentMethodsSchemaEnsured = true;
+    }
+    catch (err) {
+        console.error('[ensurePaymentMethodsSchema] migration failed:', err);
+        throw err;
+    }
+}
+/** Best-effort variant for hot order read/write paths (see groups sibling). */
+async function ensurePaymentMethodsSchemaSafe() {
+    try {
+        await ensurePaymentMethodsSchema();
+    }
+    catch {
+        // logged inside ensurePaymentMethodsSchema
+    }
+}
+/** All methods, admin view (sorted). */
+export async function findPaymentMethods() {
+    await ensurePaymentMethodsSchema();
+    const db = getDb();
+    return db
+        .select()
+        .from(schema.paymentMethods)
+        .orderBy(asc(schema.paymentMethods.sortOrder), asc(schema.paymentMethods.createdAt));
+}
+/** Enabled methods only — what checkout offers alongside native Stripe. */
+export async function findEnabledPaymentMethods() {
+    await ensurePaymentMethodsSchema();
+    const db = getDb();
+    return db
+        .select()
+        .from(schema.paymentMethods)
+        .where(eq(schema.paymentMethods.enabled, true))
+        .orderBy(asc(schema.paymentMethods.sortOrder), asc(schema.paymentMethods.createdAt));
+}
+export async function findPaymentMethodById(id) {
+    await ensurePaymentMethodsSchema();
+    const db = getDb();
+    const rows = await db
+        .select()
+        .from(schema.paymentMethods)
+        .where(eq(schema.paymentMethods.id, id))
+        .limit(1);
+    return rows[0] ?? null;
+}
+export async function createPaymentMethod(data) {
+    await ensurePaymentMethodsSchema();
+    const db = getDb();
+    const [method] = await db
+        .insert(schema.paymentMethods)
+        .values({
+        kind: data.kind ?? 'manual',
+        name: data.name,
+        instructions: data.instructions ?? null,
+        enabled: data.enabled ?? true,
+        sortOrder: data.sortOrder ?? 0,
+        config: data.config ?? {},
+    })
+        .returning();
+    return method;
+}
+export async function updatePaymentMethod(id, data) {
+    await ensurePaymentMethodsSchema();
+    const db = getDb();
+    const set = { updatedAt: new Date() };
+    if (data.kind !== undefined)
+        set.kind = data.kind;
+    if (data.name !== undefined)
+        set.name = data.name;
+    if (data.instructions !== undefined)
+        set.instructions = data.instructions ?? null;
+    if (data.enabled !== undefined)
+        set.enabled = data.enabled;
+    if (data.sortOrder !== undefined)
+        set.sortOrder = data.sortOrder;
+    if (data.config !== undefined)
+        set.config = data.config;
+    const [method] = await db
+        .update(schema.paymentMethods)
+        .set(set)
+        .where(eq(schema.paymentMethods.id, id))
+        .returning();
+    return method ?? null;
+}
+/**
+ * Hard delete is safe: orders snapshot the method's id + LABEL at order time,
+ * so history stays readable after the method row is gone.
+ */
+export async function deletePaymentMethod(id) {
+    await ensurePaymentMethodsSchema();
+    const db = getDb();
+    const deleted = await db
+        .delete(schema.paymentMethods)
+        .where(eq(schema.paymentMethods.id, id))
+        .returning({ id: schema.paymentMethods.id });
+    return deleted.length > 0;
+}
+// =============================================================================
 // Order Queries (for admin module)
 // =============================================================================
 /**