feat: a negotiable listing is buyable at its asking price too

Author: beanbocchi

CLAUDE.md

@@ -327,16 +327,16 @@ give it its own doc under `docs/` and link it from here.
   *identifiers* (schema/table/column/type/constraint names) stay `snake_case`;
   only the stored value strings are kebab. Multi-word: `product-spu`,
   `awaiting-buyer-action`, `awaiting-seller-review`.
-- **A seller never approves an order; the money creates it.** `price_mode` is the only thing
-  that differs between the two ways a sale starts. `fixed` is bought from the listing page: the
-  buyer checks out a draft, pays the item plus the shipping quote, and the order and its shipment
-  exist as soon as that payment session completes. `negotiable` cannot be checked out — the buyer
-  opens a negotiation, which is the chat thread the pair already shares, either side revises the
-  terms, and agreeing opens the same checkout. So the only thing a seller can refuse
-  is a price, and there is no route that turns paid items into an order: the payment webhook
-  does, which is why `item.order_id` is nullable and `item_seller_pending_idx` is a retry list
-  rather than an inbox. The buyer always pays delivery, so a seller is never charged and
-  `session_kind` has no `seller-confirmation-fee`.
+- **A seller never approves an order; the money creates it.** Every listing is buyable from its
+  page: the buyer checks out a draft that froze the seller's asking price, pays the item plus the
+  shipping quote, and the order and its shipment exist as soon as that payment session completes.
+  `price_mode` adds a path rather than replacing one — `negotiable` also lets the buyer open a
+  negotiation (the chat thread the pair already shares), either side revises the terms, and agreeing
+  freezes them for the same checkout; `fixed` refuses to be negotiated, which is now the only thing
+  the mode decides. So the only thing a seller can refuse is a price, and there is no route that
+  turns paid items into an order: the payment webhook does, which is why `item.order_id` is nullable
+  and `item_seller_pending_idx` is a retry list rather than an inbox. The buyer always pays
+  delivery, so a seller is never charged and `session_kind` has no `seller-confirmation-fee`.
 - **A claim is taken before the money, and the write is the claim.** A draft is spent
   (`WHERE cancelled_at IS NULL`) and an accepted offer moves to `checked-out`
   (`WHERE status = 'accepted'`) *before* anything is reserved or a payment session is opened, so a
@@ -353,8 +353,9 @@ give it its own doc under `docs/` and link it from here.
   acceptance landed would put terms back on a table that was already agreed, and the buyer holding
   a 200 "agreed" would then be told their checkout has nothing to check out. Same rule as
   `Version` on an aggregate — a stale read has to lose.
-- **Agreeing to a price is not the sale; the buyer's checkout is.** Either party may accept the
-  terms on the table — whoever does *not* own the standing proposal, since the two sides
+- **Agreeing to a price is not the sale; the buyer's checkout is.** (Nor is negotiating the only
+  way to buy a `negotiable` listing — the asking price is takeable, see above.) Either party may
+  accept the terms on the table — whoever does *not* own the standing proposal, since the two sides
   alternate — and that charges nothing: it freezes the price for `acceptedWindow` (30 minutes,
   against `offerWindow`'s 12 hours) and the buyer then presses "create order now", which is the
   same checkout a fixed-price listing opens. That split is what makes a *seller* accepting safe:

api/openapi.gen.yaml

@@ -2537,7 +2537,7 @@ components:
 
                 `fixed` is bought straight from the listing page: the buyer checks out, pays the item plus the shipping quote, and the order and its shipment exist as soon as the money lands. The seller confirms nothing.
 
-                `negotiable` cannot be checked out. The buyer opens a negotiation, which is a thread in chat where either side revises the terms, and accepting them is what starts the same checkout. Either way the seller never approves an order — the only thing they can refuse is a price.
+                `negotiable` adds a second way to buy without removing the first: the asking price is still a price a buyer can take outright, and the listing page asks which they want. If they haggle, the negotiation is a thread in chat where either side revises the terms, and agreeing freezes them for the same checkout. Either way the seller never approves an order — the only thing they can refuse is a price.
             enum:
                 - fixed
                 - negotiable
@@ -6574,7 +6574,7 @@ paths:
             description: |
                 Freezes the listing terms so a price the seller edits afterwards cannot be charged. The server snapshots the listing together with every variant — price and package details live on the variant, and those are exactly what must not move under the buyer — and sets `valid_until`.
 
-                Only a `fixed` listing has one: a `negotiable` price is agreed in an offer, and the accepted offer is what freezes its terms instead. Asking for one is 422.
+                Every listing has one, whichever way it is priced. A `negotiable` listing carries the seller's asking price like any other, and a buyer who does not want to haggle takes it: the listing page offers both, and this is the "buy now" half. Negotiating instead freezes the agreed terms in the offer, and `POST /offers/{id}/checkout` is the same checkout from there.
             requestBody:
                 content:
                     application/json:
@@ -6603,12 +6603,6 @@ paths:
                             schema:
                                 $ref: '#/components/schemas/Error'
                     description: Listing not found, deleted, or not active
-                "422":
-                    content:
-                        application/json:
-                            schema:
-                                $ref: '#/components/schemas/Error'
-                    description: The listing is priced negotiable; open an offer instead
             security:
                 - bearerAuth: []
             summary: Open a purchase session for one listing
@@ -6670,7 +6664,7 @@ paths:
 
                 The session is spent before the money is asked for: the claim is what makes two concurrent checkouts of one draft impossible, and the loser is answered 409 rather than handed a second payment session for the same frozen price.
 
-                A `negotiable` listing has no draft at all, so there is nothing to check out here — its terms are frozen by the offer both sides agreed on, and `POST /offers/{id}/checkout` is the same checkout from there. The buyer pays delivery either way.
+                This is the checkout for terms a draft froze — the seller's own price, whether the listing is `fixed` or `negotiable`. Terms that were *negotiated* are checked out at `POST /offers/{id}/checkout` instead, which is the same flow against the agreed price. The buyer pays delivery either way.
             parameters:
                 - in: path
                   name: id

internal/module/catalog/api/openapi/listing.yaml

@@ -497,10 +497,11 @@ components:
         money lands. The seller confirms nothing.
 
 
-        `negotiable` cannot be checked out. The buyer opens a negotiation, which is a
-        thread in chat where either side revises the terms, and accepting them is what
-        starts the same checkout. Either way the seller never approves an order — the only
-        thing they can refuse is a price.
+        `negotiable` adds a second way to buy without removing the first: the asking price is
+        still a price a buyer can take outright, and the listing page asks which they want. If they
+        haggle, the negotiation is a thread in chat where either side revises the terms, and
+        agreeing freezes them for the same checkout. Either way the seller never approves an order —
+        the only thing they can refuse is a price.
       enum: [fixed, negotiable]
 
     PublishListingRequest:

internal/module/common/uploads/uploads_integration_test.go

@@ -5,6 +5,7 @@ package uploads_test
 import (
 	"context"
 	"errors"
+	"fmt"
 	"os"
 	"strings"
 	"testing"
@@ -202,8 +203,10 @@ func TestResolveUsesTheStoreEachRowNames(t *testing.T) {
 	}
 
 	// One imported row, held at another origin — what cmd/seed writes. Inserted directly
-	// because no route can create one: an upload always goes to the write store.
-	const cdnURL = "https://cdn.example.com/file/imported_tn"
+	// because no route can create one: an upload always goes to the write store. The key is unique
+	// per run, since `resource` has one row per (provider, object_key) and these rows outlive a
+	// test — a fixed key passes once and then collides for ever.
+	cdnURL := fmt.Sprintf("https://cdn.example.com/file/imported_%d", who)
 	imported, err := common.NewResource(&who, remote.Name, cdnURL, "image/jpeg", 0, nil, nil)
 	if err != nil {
 		t.Fatalf("NewResource: %v", err)

internal/module/order/api/openapi/draft-order.yaml

@@ -12,8 +12,10 @@ paths:
         not move under the buyer — and sets `valid_until`.
 
 
-        Only a `fixed` listing has one: a `negotiable` price is agreed in an offer, and the
-        accepted offer is what freezes its terms instead. Asking for one is 422.
+        Every listing has one, whichever way it is priced. A `negotiable` listing carries the
+        seller's asking price like any other, and a buyer who does not want to haggle takes it: the
+        listing page offers both, and this is the "buy now" half. Negotiating instead freezes the
+        agreed terms in the offer, and `POST /offers/{id}/checkout` is the same checkout from there.
       security: [{ bearerAuth: [] }]
       requestBody:
         required: true
@@ -33,7 +35,6 @@ paths:
         '400': { $ref: '#/components/responses/BadRequest' }
         '401': { $ref: '#/components/responses/Unauthorized' }
         '404': { description: 'Listing not found, deleted, or not active', content: { application/json: { schema: { $ref: '#/components/schemas/Error' } } } }
-        '422': { description: 'The listing is priced negotiable; open an offer instead', content: { application/json: { schema: { $ref: '#/components/schemas/Error' } } } }
     get:
       tags: [order]
       summary: List the caller's purchase sessions
@@ -95,9 +96,10 @@ paths:
         than handed a second payment session for the same frozen price.
 
 
-        A `negotiable` listing has no draft at all, so there is nothing to check out here — its
-        terms are frozen by the offer both sides agreed on, and `POST /offers/{id}/checkout` is the
-        same checkout from there. The buyer pays delivery either way.
+        This is the checkout for terms a draft froze — the seller's own price, whether the listing
+        is `fixed` or `negotiable`. Terms that were *negotiated* are checked out at
+        `POST /offers/{id}/checkout` instead, which is the same flow against the agreed price. The
+        buyer pays delivery either way.
       security: [{ bearerAuth: [] }]
       parameters:
         - { name: id, in: path, required: true, schema: { $ref: '#/components/schemas/DraftOrderID' } }

internal/module/order/api/openapi/offer.yaml

@@ -1,4 +1,4 @@
-# order fragment: offer — the negotiation a `negotiable` listing has to go through.
+# order fragment: offer — the negotiation a `negotiable` listing offers instead of its asking price.
 #
 # It is conducted in the chat thread the two accounts already share (chat has one thread per
 # pair, so there is nothing to create and nothing to address it by): every route here also

internal/module/order/api/openapi/order.yaml

@@ -6,13 +6,13 @@
 # next to this one.
 #
 # Two shapes recur:
-#   - Checkout is PAY-FIRST, and the money is what creates the order. A fixed-price
-#     listing freezes its terms in a draft; a negotiable one freezes them in the offer
-#     both sides accepted — either party may agree, which charges nothing and starts a
-#     short window for the buyer's "create order now". Either way checkout writes the
-#     items plus one buyer-checkout payment session, and the order appears when that
-#     session completes. There is no endpoint for it and no seller confirmation: a
-#     seller can refuse a price, never an order.
+#   - Checkout is PAY-FIRST, and the money is what creates the order. A draft freezes the
+#     seller's asking price, which every listing has however it is priced; a negotiation
+#     freezes agreed terms in the offer instead — either party may agree, which charges
+#     nothing and starts a short window for the buyer's "create order now". Either way
+#     checkout writes the items plus one buyer-checkout payment session, and the order
+#     appears when that session completes. It has no endpoint of its own and no seller
+#     confirmation anywhere: a seller can refuse a price, never an order.
 #   - Delivery is the buyer's on both paths, and it is quoted from the carrier at
 #     checkout rather than sent — the session asks for goods plus that fee, and only the
 #     goods are ever held for or released to the seller. `POST /shipping-quotes` prices

internal/module/order/domain/errors.go

@@ -13,15 +13,12 @@ var (
 	ErrCartItemNotFound = errx.NewError(http.StatusNotFound, "cart_item_not_found", "cart item not found")
 
 	// --- drafts and checkout ---
-	ErrDraftNotFound = errx.NewError(http.StatusNotFound, "draft_not_found", "purchase session not found")
-	ErrDraftExpired  = errx.NewError(http.StatusConflict, "draft_expired", "this purchase session has expired")
-	ErrDraftSettled  = errx.NewError(http.StatusConflict, "draft_settled", "this purchase session is already cancelled or checked out")
-	// ErrNegotiableNeedsOffer is a checkout of a listing priced `negotiable`. It cannot be
-	// bought from the listing page: the price is agreed in a negotiation first.
-	ErrNegotiableNeedsOffer = errx.NewError(http.StatusUnprocessableEntity, "negotiable_needs_offer", "a negotiable listing is bought through an accepted offer")
-	ErrPriceMoved           = errx.NewError(http.StatusConflict, "price_moved", "the frozen terms no longer match the listing")
-	ErrCurrencyMismatch     = errx.NewError(http.StatusUnprocessableEntity, "currency_mismatch", "the currency does not match the listing's")
-	ErrVariantNotInDraft    = errx.NewError(http.StatusUnprocessableEntity, "variant_not_in_draft", "that variant is not in this purchase session")
+	ErrDraftNotFound     = errx.NewError(http.StatusNotFound, "draft_not_found", "purchase session not found")
+	ErrDraftExpired      = errx.NewError(http.StatusConflict, "draft_expired", "this purchase session has expired")
+	ErrDraftSettled      = errx.NewError(http.StatusConflict, "draft_settled", "this purchase session is already cancelled or checked out")
+	ErrPriceMoved        = errx.NewError(http.StatusConflict, "price_moved", "the frozen terms no longer match the listing")
+	ErrCurrencyMismatch  = errx.NewError(http.StatusUnprocessableEntity, "currency_mismatch", "the currency does not match the listing's")
+	ErrVariantNotInDraft = errx.NewError(http.StatusUnprocessableEntity, "variant_not_in_draft", "that variant is not in this purchase session")
 
 	// --- items ---
 	ErrItemNotFound = errx.NewError(http.StatusNotFound, "item_not_found", "item not found")

internal/module/order/service_draft.go

@@ -15,19 +15,17 @@ import (
 	"shopnexus/internal/shared/id"
 )
 
-// CreateDraft opens a purchase session by freezing the listing's terms. A listing priced
-// `negotiable` has no draft: its price is agreed in a negotiation, and there is nothing to
-// freeze until somebody accepts.
+// CreateDraft opens a purchase session by freezing the listing's terms — for any listing, however
+// it is priced. A `negotiable` one carries an asking price like any other, and a buyer who does not
+// want to haggle takes it: the listing page asks which they want, and this is the "buy now" half.
+// Negotiating instead freezes the agreed terms in the offer, and its own checkout spends those.
 func (s *Service) CreateDraft(ctx context.Context, req orderapi.CreateDraftRequest) (orderapi.Draft, error) {
 	listing, err := s.catalog.GetListing(ctx, catalogapi.GetListingRequest{
 		ID: req.ListingID, ViewerID: req.ActorID,
 	})
 	if err != nil {
 		return orderapi.Draft{}, fmt.Errorf("get listing: %w", err)
 	}
-	if listing.PriceMode != catalogapi.PriceModeFixed {
-		return orderapi.Draft{}, domain.ErrNegotiableNeedsOffer
-	}
 	snapshot := domain.ListingSnapshot{
 		ListingID: listing.ID.Int64(),
 		SellerID:  listing.Seller.ID.Int64(),