@unifiedcommerce/plugin-marketplace 0.0.1

package/src/services/commission.ts

@@ -0,0 +1,120 @@
+import { eq, and, desc, lte, gte, isNull, or } from "drizzle-orm";
+import { commissionRules, vendors } from "../schema";
+import type { Db, MarketplacePluginOptions } from "../types";
+
+export class CommissionService {
+  constructor(
+    private db: Db,
+    private options: MarketplacePluginOptions,
+  ) {}
+
+  async createRule(data: {
+    name: string;
+    type: string;
+    rateBps: number;
+    categorySlug?: string;
+    vendorId?: string;
+    vendorTier?: string;
+    minVolumeCents?: number;
+    maxVolumeCents?: number;
+    validFrom?: Date | undefined;
+    validUntil?: Date | undefined;
+    priority?: number;
+  }) {
+    const [rule] = await this.db.insert(commissionRules).values(data).returning();
+    return rule;
+  }
+
+  async updateRule(id: string, data: Record<string, unknown>) {
+    const [updated] = await this.db.update(commissionRules).set(data)
+      .where(eq(commissionRules.id, id)).returning();
+    return updated ?? null;
+  }
+
+  async deleteRule(id: string) {
+    await this.db.delete(commissionRules).where(eq(commissionRules.id, id));
+  }
+
+  async listRules() {
+    return this.db.select().from(commissionRules).orderBy(desc(commissionRules.priority));
+  }
+
+  /**
+   * Resolve the effective commission rate for a given vendor+category+volume.
+   * Priority order per RFC §5.2:
+   *   1. Vendor-specific + category-specific
+   *   2. Category-specific (any vendor)
+   *   3. Vendor tier rule
+   *   4. Volume tier rule
+   *   5. Promotional rule
+   *   6. Vendor-level flat rate
+   *   7. Plugin default
+   */
+  async resolveRate(vendorId: string, categorySlug?: string, volumeCents?: number): Promise<number> {
+    const now = new Date();
+    const rules = await this.db.select().from(commissionRules)
+      .where(eq(commissionRules.isActive, true))
+      .orderBy(desc(commissionRules.priority));
+
+    // Load vendor for tier and flat rate fallback
+    const [vendor] = await this.db.select().from(vendors).where(eq(vendors.id, vendorId));
+
+    for (const rule of rules) {
+      // Check time validity
+      if (rule.validFrom && rule.validFrom > now) continue;
+      if (rule.validUntil && rule.validUntil < now) continue;
+
+      // 1. Vendor-specific + category-specific
+      if (rule.type === "category" && rule.vendorId === vendorId && rule.categorySlug === categorySlug) {
+        return rule.rateBps;
+      }
+    }
+
+    for (const rule of rules) {
+      if (rule.validFrom && rule.validFrom > now) continue;
+      if (rule.validUntil && rule.validUntil < now) continue;
+
+      // 2. Category-specific (any vendor)
+      if (rule.type === "category" && !rule.vendorId && rule.categorySlug === categorySlug) {
+        return rule.rateBps;
+      }
+    }
+
+    for (const rule of rules) {
+      if (rule.validFrom && rule.validFrom > now) continue;
+      if (rule.validUntil && rule.validUntil < now) continue;
+
+      // 3. Vendor tier
+      if (rule.type === "vendor_tier" && vendor && rule.vendorTier === vendor.tier) {
+        return rule.rateBps;
+      }
+
+      // 4. Volume tier
+      if (rule.type === "volume_tier" && volumeCents != null) {
+        const min = rule.minVolumeCents ?? 0;
+        const max = rule.maxVolumeCents ?? Number.MAX_SAFE_INTEGER;
+        if (volumeCents >= min && volumeCents <= max) {
+          return rule.rateBps;
+        }
+      }
+
+      // 5. Promotional
+      if (rule.type === "promotional") {
+        if (!rule.vendorId || rule.vendorId === vendorId) {
+          return rule.rateBps;
+        }
+      }
+    }
+
+    // 6. Vendor flat rate
+    if (vendor) return vendor.commissionRateBps;
+
+    // 7. Plugin default
+    return this.options.defaultCommissionRateBps ?? 1000;
+  }
+
+  async previewRate(vendorId: string, categorySlug?: string, volumeCents?: number) {
+    const rateBps = await this.resolveRate(vendorId, categorySlug, volumeCents);
+    return { rateBps, ratePercent: rateBps / 100 };
+  }
+}

package/src/services/contract-price.ts

@@ -0,0 +1,80 @@
+import { eq, and, desc, lte, gte, isNull, or } from "drizzle-orm";
+import { contractPrices } from "../schema";
+import type { Db } from "../types";
+
+export class ContractPriceService {
+  constructor(private db: Db) {}
+
+  async create(data: {
+    vendorId: string;
+    buyerId: string;
+    entityId: string;
+    variantId?: string;
+    priceCents: number;
+    minQuantity?: number;
+    currency?: string;
+    validFrom?: Date | undefined;
+    validUntil?: Date | undefined;
+  }) {
+    const [price] = await this.db.insert(contractPrices).values(data).returning();
+    return price;
+  }
+
+  async update(id: string, data: Record<string, unknown>) {
+    const [updated] = await this.db.update(contractPrices).set(data)
+      .where(eq(contractPrices.id, id)).returning();
+    return updated ?? null;
+  }
+
+  async delete(id: string) {
+    await this.db.delete(contractPrices).where(eq(contractPrices.id, id));
+  }
+
+  async list(filters?: { vendorId?: string; buyerId?: string }) {
+    let query = this.db.select().from(contractPrices).$dynamic();
+    const conditions = [];
+    if (filters?.vendorId) conditions.push(eq(contractPrices.vendorId, filters.vendorId));
+    if (filters?.buyerId) conditions.push(eq(contractPrices.buyerId, filters.buyerId));
+    if (conditions.length > 0) {
+      query = query.where(conditions.length === 1 ? conditions[0]! : and(...conditions));
+    }
+    return query.orderBy(desc(contractPrices.createdAt));
+  }
+
+  /**
+   * Resolve the best contract price for a buyer+vendor+entity+quantity.
+   * Returns null if no matching contract exists.
+   */
+  async resolvePrice(
+    vendorId: string,
+    buyerId: string,
+    entityId: string,
+    variantId: string | null,
+    quantity: number,
+  ): Promise<number | null> {
+    const now = new Date();
+    const all = await this.db.select().from(contractPrices)
+      .where(
+        and(
+          eq(contractPrices.vendorId, vendorId),
+          eq(contractPrices.buyerId, buyerId),
+          eq(contractPrices.entityId, entityId),
+        ),
+      )
+      .orderBy(desc(contractPrices.priceCents));
+
+    for (const cp of all) {
+      // Check variant match
+      if (variantId != null && cp.variantId != null && cp.variantId !== variantId) continue;
+      // Check quantity
+      if (quantity < (cp.minQuantity ?? 1)) continue;
+      // Check time validity
+      if (cp.validFrom && cp.validFrom > now) continue;
+      if (cp.validUntil && cp.validUntil < now) continue;
+
+      return cp.priceCents;
+    }
+
+    return null;
+  }
+}

package/src/services/dispute.ts

@@ -0,0 +1,92 @@
+import { eq, and, desc } from "drizzle-orm";
+import { disputes } from "../schema";
+import type { Db, DisputeStatus, DisputeResolution, MarketplacePluginOptions } from "../types";
+
+export class DisputeService {
+  constructor(
+    private db: Db,
+    private options: MarketplacePluginOptions,
+  ) {}
+
+  async open(data: {
+    subOrderId: string;
+    openedBy: string;
+    reason: string;
+    description?: string;
+  }) {
+    const deadlineDays = this.options.vendorResponseDeadlineDays ?? 3;
+    const deadline = new Date();
+    deadline.setDate(deadline.getDate() + deadlineDays);
+
+    const [dispute] = await this.db.insert(disputes).values({
+      subOrderId: data.subOrderId,
+      openedBy: data.openedBy,
+      reason: data.reason,
+      description: data.description,
+      status: "vendor_response_pending",
+      deadlineAt: deadline,
+    }).returning();
+    return dispute;
+  }
+
+  async getById(id: string) {
+    const [dispute] = await this.db.select().from(disputes).where(eq(disputes.id, id));
+    return dispute ?? null;
+  }
+
+  async list(filters?: { status?: string; subOrderId?: string }) {
+    let query = this.db.select().from(disputes).$dynamic();
+    const conditions = [];
+    if (filters?.status) conditions.push(eq(disputes.status, filters.status));
+    if (filters?.subOrderId) conditions.push(eq(disputes.subOrderId, filters.subOrderId));
+    if (conditions.length > 0) {
+      query = query.where(conditions.length === 1 ? conditions[0]! : and(...conditions));
+    }
+    return query.orderBy(desc(disputes.openedAt));
+  }
+
+  async respond(id: string, data: { party: string; note: string; url?: string }) {
+    const dispute = await this.getById(id);
+    if (!dispute) throw new Error("Dispute not found.");
+
+    const evidence = [...(dispute.evidence as Array<{ party: string; type: string; url?: string; note?: string; at: string }> ?? [])];
+    const entry: { party: string; type: string; note: string; at: string; url?: string } = {
+      party: data.party,
+      type: "response",
+      note: data.note,
+      at: new Date().toISOString(),
+    };
+    if (data.url) entry.url = data.url;
+    evidence.push(entry);
+
+    const [updated] = await this.db.update(disputes).set({
+      evidence,
+      status: "platform_review",
+    }).where(eq(disputes.id, id)).returning();
+    return updated;
+  }
+
+  async escalate(id: string) {
+    const [updated] = await this.db.update(disputes).set({
+      status: "escalated" as DisputeStatus,
+    }).where(eq(disputes.id, id)).returning();
+    return updated ?? null;
+  }
+
+  async resolve(id: string, data: {
+    resolution: DisputeResolution;
+    notes?: string;
+    refundAmountCents?: number;
+    resolvedBy: string;
+  }) {
+    const [updated] = await this.db.update(disputes).set({
+      status: "resolved" as DisputeStatus,
+      resolution: data.resolution,
+      resolutionNotes: data.notes,
+      refundAmountCents: data.refundAmountCents,
+      resolvedBy: data.resolvedBy,
+      resolvedAt: new Date(),
+    }).where(eq(disputes.id, id)).returning();
+    return updated ?? null;
+  }
+}

package/src/services/payout.ts

@@ -0,0 +1,154 @@
+import { eq, and, desc, sql, lte } from "drizzle-orm";
+import { vendorPayouts, vendorBalances, vendors, vendorSubOrders } from "../schema";
+import type { Db, BalanceEntryType, MarketplacePluginOptions } from "../types";
+
+export class PayoutService {
+  constructor(
+    private db: Db,
+    private options: MarketplacePluginOptions,
+  ) {}
+
+  // ─── Balance Ledger ────────────────────────────────────────────────────────
+
+  async addLedgerEntry(data: {
+    vendorId: string;
+    type: BalanceEntryType;
+    amountCents: number;
+    referenceType?: string;
+    referenceId?: string;
+    description?: string;
+  }) {
+    // Get current balance
+    const balance = await this.getBalance(data.vendorId);
+    const newBalance = balance + data.amountCents;
+
+    const [entry] = await this.db.insert(vendorBalances).values({
+      vendorId: data.vendorId,
+      type: data.type,
+      amountCents: data.amountCents,
+      runningBalanceCents: newBalance,
+      referenceType: data.referenceType,
+      referenceId: data.referenceId,
+      description: data.description,
+    }).returning();
+    return entry;
+  }
+
+  async getBalance(vendorId: string): Promise<number> {
+    const rows = await this.db.select({
+      balance: sql<number>`COALESCE((
+        SELECT running_balance_cents FROM marketplace_vendor_balances
+        WHERE vendor_id = ${vendorId}
+        ORDER BY created_at DESC LIMIT 1
+      ), 0)`,
+    }).from(vendors).where(eq(vendors.id, vendorId));
+    return rows[0]?.balance ?? 0;
+  }
+
+  async getLedger(vendorId: string, limit = 50) {
+    return this.db.select().from(vendorBalances)
+      .where(eq(vendorBalances.vendorId, vendorId))
+      .orderBy(desc(vendorBalances.createdAt))
+      .limit(limit);
+  }
+
+  // ─── Payouts ───────────────────────────────────────────────────────────────
+
+  async getPayoutById(id: string) {
+    const [payout] = await this.db.select().from(vendorPayouts).where(eq(vendorPayouts.id, id));
+    return payout ?? null;
+  }
+
+  async listPayouts(filters?: { vendorId?: string; status?: string }) {
+    let query = this.db.select().from(vendorPayouts).$dynamic();
+    const conditions = [];
+    if (filters?.vendorId) conditions.push(eq(vendorPayouts.vendorId, filters.vendorId));
+    if (filters?.status) conditions.push(eq(vendorPayouts.status, filters.status));
+    if (conditions.length > 0) {
+      query = query.where(conditions.length === 1 ? conditions[0]! : and(...conditions));
+    }
+    return query.orderBy(desc(vendorPayouts.createdAt));
+  }
+
+  /**
+   * Run payout cycle for eligible vendors.
+   * Per RFC §5.5:
+   * 1. Find vendors with matching payout_schedule
+   * 2. Check balance >= payout_minimum_cents
+   * 3. Only include deliveries older than holdback_days
+   * 4. Calculate deductions (refunds, adjustments)
+   * 5. Create payout record + balance ledger debit
+   */
+  async runPayoutCycle(): Promise<Array<{ vendorId: string; payoutId: string; netAmount: number }>> {
+    const allVendors = await this.db.select().from(vendors)
+      .where(eq(vendors.status, "approved"));
+
+    const results: Array<{ vendorId: string; payoutId: string; netAmount: number }> = [];
+
+    for (const vendor of allVendors) {
+      const balance = await this.getBalance(vendor.id);
+      const minimum = vendor.payoutMinimumCents ?? this.options.defaultPayoutMinimumCents ?? 5000;
+
+      if (balance < minimum) continue;
+
+      const grossAmount = balance;
+      const deductions: Array<{ type: string; amount: number; reference?: string }> = [];
+      const netAmount = grossAmount - deductions.reduce((sum, d) => sum + d.amount, 0);
+
+      if (netAmount <= 0) continue;
+
+      const [payout] = await this.db.insert(vendorPayouts).values({
+        vendorId: vendor.id,
+        amount: netAmount,
+        status: "processing",
+        grossAmount,
+        deductions,
+        netAmount,
+        periodEnd: new Date(),
+      }).returning();
+
+      if (!payout) continue;
+
+      // Debit vendor balance
+      await this.addLedgerEntry({
+        vendorId: vendor.id,
+        type: "payout",
+        amountCents: -netAmount,
+        referenceType: "payout",
+        referenceId: payout.id,
+        description: `Payout #${payout.id.slice(0, 8)}`,
+      });
+
+      // Mark as completed (in a real system, this would wait for bank transfer confirmation)
+      await this.db.update(vendorPayouts).set({
+        status: "completed",
+        processedAt: new Date(),
+      }).where(eq(vendorPayouts.id, payout.id));
+
+      results.push({ vendorId: vendor.id, payoutId: payout.id, netAmount });
+    }
+
+    return results;
+  }
+
+  async retryPayout(payoutId: string) {
+    const payout = await this.getPayoutById(payoutId);
+    if (!payout) throw new Error("Payout not found.");
+    if (payout.status !== "failed") throw new Error("Only failed payouts can be retried.");
+
+    const [updated] = await this.db.update(vendorPayouts).set({
+      status: "processing",
+      retryCount: (payout.retryCount ?? 0) + 1,
+      failedAt: null,
+      failureReason: null,
+    }).where(eq(vendorPayouts.id, payoutId)).returning();
+
+    // Mark completed (simplified — real implementation calls payment provider)
+    await this.db.update(vendorPayouts).set({
+      status: "completed",
+      processedAt: new Date(),
+    }).where(eq(vendorPayouts.id, payoutId));
+
+    return updated;
+  }
+}

package/src/services/return.ts

@@ -0,0 +1,92 @@
+import { eq, and, desc } from "drizzle-orm";
+import { returnRequests, vendorSubOrders } from "../schema";
+import type { Db, ReturnStatus } from "../types";
+
+export class ReturnService {
+  constructor(private db: Db) {}
+
+  async request(data: {
+    subOrderId: string;
+    customerId?: string;
+    reason: string;
+    description?: string;
+    lineItems?: Array<{ entityId: string; quantity: number; reason?: string }>;
+  }) {
+    const [req] = await this.db.insert(returnRequests).values({
+      subOrderId: data.subOrderId,
+      customerId: data.customerId,
+      reason: data.reason,
+      description: data.description,
+      lineItems: data.lineItems,
+    }).returning();
+    return req;
+  }
+
+  async getById(id: string) {
+    const [req] = await this.db.select().from(returnRequests).where(eq(returnRequests.id, id));
+    return req ?? null;
+  }
+
+  async list(filters?: { subOrderId?: string; status?: string }) {
+    let query = this.db.select().from(returnRequests).$dynamic();
+    const conditions = [];
+    if (filters?.subOrderId) conditions.push(eq(returnRequests.subOrderId, filters.subOrderId));
+    if (filters?.status) conditions.push(eq(returnRequests.status, filters.status));
+    if (conditions.length > 0) {
+      query = query.where(conditions.length === 1 ? conditions[0]! : and(...conditions));
+    }
+    return query.orderBy(desc(returnRequests.requestedAt));
+  }
+
+  async listByVendor(vendorId: string) {
+    const subOrders = await this.db.select().from(vendorSubOrders)
+      .where(eq(vendorSubOrders.vendorId, vendorId));
+    const subOrderIds = subOrders.map((s: { id: string }) => s.id);
+    if (subOrderIds.length === 0) return [];
+
+    const all = await this.db.select().from(returnRequests)
+      .orderBy(desc(returnRequests.requestedAt));
+    return all.filter((r: { subOrderId: string }) => subOrderIds.includes(r.subOrderId));
+  }
+
+  async vendorApprove(id: string, refundAmountCents?: number) {
+    const [updated] = await this.db.update(returnRequests).set({
+      status: "vendor_approved" as ReturnStatus,
+      refundAmountCents,
+    }).where(eq(returnRequests.id, id)).returning();
+    return updated ?? null;
+  }
+
+  async vendorReject(id: string, notes?: string) {
+    const [updated] = await this.db.update(returnRequests).set({
+      status: "vendor_rejected" as ReturnStatus,
+      vendorNotes: notes,
+      resolvedAt: new Date(),
+    }).where(eq(returnRequests.id, id)).returning();
+    return updated ?? null;
+  }
+
+  async shipBack(id: string, trackingNumber: string) {
+    const [updated] = await this.db.update(returnRequests).set({
+      status: "shipped_back" as ReturnStatus,
+      trackingNumber,
+    }).where(eq(returnRequests.id, id)).returning();
+    return updated ?? null;
+  }
+
+  async receive(id: string) {
+    const [updated] = await this.db.update(returnRequests).set({
+      status: "received" as ReturnStatus,
+    }).where(eq(returnRequests.id, id)).returning();
+    return updated ?? null;
+  }
+
+  async refund(id: string, amountCents: number) {
+    const [updated] = await this.db.update(returnRequests).set({
+      status: "refunded" as ReturnStatus,
+      refundAmountCents: amountCents,
+      resolvedAt: new Date(),
+    }).where(eq(returnRequests.id, id)).returning();
+    return updated ?? null;
+  }
+}

package/src/services/review.ts

@@ -0,0 +1,76 @@
+import { eq, and, desc, sql, avg } from "drizzle-orm";
+import { vendorReviews } from "../schema";
+import type { Db, ReviewStatus, MarketplacePluginOptions } from "../types";
+
+export class ReviewService {
+  constructor(
+    private db: Db,
+    private options: MarketplacePluginOptions,
+  ) {}
+
+  async create(data: {
+    vendorId: string;
+    customerId?: string;
+    orderId?: string;
+    rating: number;
+    title?: string;
+    body?: string;
+  }) {
+    if (data.rating < 1 || data.rating > 5) {
+      throw new Error("Rating must be between 1 and 5.");
+    }
+
+    const status: ReviewStatus = this.options.reviewModerationEnabled ? "pending" : "published";
+
+    const [review] = await this.db.insert(vendorReviews).values({
+      vendorId: data.vendorId,
+      customerId: data.customerId,
+      orderId: data.orderId,
+      rating: data.rating,
+      title: data.title,
+      body: data.body,
+      status,
+    }).returning();
+    return review;
+  }
+
+  async getForVendor(vendorId: string, includeUnpublished = false) {
+    let query = this.db.select().from(vendorReviews).$dynamic();
+    if (includeUnpublished) {
+      query = query.where(eq(vendorReviews.vendorId, vendorId));
+    } else {
+      query = query.where(
+        and(eq(vendorReviews.vendorId, vendorId), eq(vendorReviews.status, "published")),
+      );
+    }
+    return query.orderBy(desc(vendorReviews.createdAt));
+  }
+
+  async getAggregateRating(vendorId: string): Promise<{ average: number; count: number }> {
+    const rows = await this.db.select({
+      avg: sql<number>`COALESCE(AVG(${vendorReviews.rating}), 0)`,
+      count: sql<number>`COUNT(*)`,
+    }).from(vendorReviews)
+      .where(and(eq(vendorReviews.vendorId, vendorId), eq(vendorReviews.status, "published")));
+
+    const row = rows[0];
+    return {
+      average: Math.round((Number(row?.avg) || 0) * 10) / 10,
+      count: Number(row?.count) || 0,
+    };
+  }
+
+  async respond(reviewId: string, response: string) {
+    const [updated] = await this.db.update(vendorReviews).set({
+      vendorResponse: response,
+      vendorRespondedAt: new Date(),
+    }).where(eq(vendorReviews.id, reviewId)).returning();
+    return updated ?? null;
+  }
+
+  async moderate(reviewId: string, status: ReviewStatus) {
+    const [updated] = await this.db.update(vendorReviews).set({ status })
+      .where(eq(vendorReviews.id, reviewId)).returning();
+    return updated ?? null;
+  }
+}

package/src/services/rfq.ts

@@ -0,0 +1,82 @@
+import { eq, and, desc } from "drizzle-orm";
+import { rfqs, rfqResponses } from "../schema";
+import type { Db, RFQStatus, RFQResponseStatus } from "../types";
+
+export class RFQService {
+  constructor(private db: Db) {}
+
+  async create(data: {
+    buyerId?: string;
+    title: string;
+    description?: string;
+    categorySlug?: string;
+    quantity?: number;
+    budgetCents?: number;
+    currency?: string;
+    deadlineAt?: Date | undefined;
+    metadata?: Record<string, unknown>;
+  }) {
+    const [rfq] = await this.db.insert(rfqs).values(data).returning();
+    return rfq;
+  }
+
+  async getById(id: string) {
+    const [rfq] = await this.db.select().from(rfqs).where(eq(rfqs.id, id));
+    return rfq ?? null;
+  }
+
+  async list(filters?: { status?: string; categorySlug?: string }) {
+    let query = this.db.select().from(rfqs).$dynamic();
+    const conditions = [];
+    if (filters?.status) conditions.push(eq(rfqs.status, filters.status));
+    if (filters?.categorySlug) conditions.push(eq(rfqs.categorySlug, filters.categorySlug));
+    if (conditions.length > 0) {
+      query = query.where(conditions.length === 1 ? conditions[0]! : and(...conditions));
+    }
+    return query.orderBy(desc(rfqs.createdAt));
+  }
+
+  async respond(rfqId: string, data: {
+    vendorId: string;
+    unitPriceCents: number;
+    totalPriceCents: number;
+    leadTimeDays?: number;
+    notes?: string;
+  }) {
+    const [response] = await this.db.insert(rfqResponses).values({
+      rfqId,
+      ...data,
+    }).returning();
+    return response;
+  }
+
+  async getResponses(rfqId: string) {
+    return this.db.select().from(rfqResponses)
+      .where(eq(rfqResponses.rfqId, rfqId))
+      .orderBy(desc(rfqResponses.createdAt));
+  }
+
+  async award(rfqId: string, vendorId: string) {
+    // Mark RFQ as awarded
+    const [updated] = await this.db.update(rfqs).set({
+      status: "awarded" as RFQStatus,
+      awardedVendorId: vendorId,
+    }).where(eq(rfqs.id, rfqId)).returning();
+
+    // Mark winning response as accepted, others as rejected
+    const responses = await this.getResponses(rfqId);
+    for (const r of responses) {
+      const status: RFQResponseStatus = r.vendorId === vendorId ? "accepted" : "rejected";
+      await this.db.update(rfqResponses).set({ status }).where(eq(rfqResponses.id, r.id));
+    }
+
+    return updated ?? null;
+  }
+
+  async close(rfqId: string) {
+    const [updated] = await this.db.update(rfqs).set({
+      status: "closed" as RFQStatus,
+    }).where(eq(rfqs.id, rfqId)).returning();
+    return updated ?? null;
+  }
+}