trustbase-seller-backend 0.7.0 → 0.7.1

package/api/seller-products.js

@@ -22,7 +22,27 @@ exports.createSellerProductsRouter = createSellerProductsRouter;
 const express_1 = require("express");
 const crypto_1 = require("crypto");
 const wallet_auth_1 = require("../middleware/wallet-auth");
+// A1: 复用 buyer-shop 的建表/迁移 (它已 export ensureBuyerTables; 无反向依赖, 无循环引用风险)
+const buyer_shop_1 = require("../routes/buyer-shop");
 const VALID_STATUSES = ['draft', 'active', 'out_of_stock', 'archived'];
+/**
+ * A1 商品类型白名单 —— 与 `buyer-shop.js` 下单侧判定**同一口径**（`physical` 要收货地址,
+ * `virtual` 免地址并生成交付凭证）。
+ *
+ * ⚠️ 这里**显式拒绝**非法值而不是静默回退成 `physical`：下单侧是
+ * `=== 'virtual' ? virtual : physical`, 若上架时误传链上枚举名（如 `saas`）却被静默存成
+ * `physical`, 买家买虚拟商品时会被迫填收货地址 —— 那是静默的业务错误, 比 400 更糟。
+ * 缺省才回退 `physical`（向后兼容：老客户端不传该字段不受影响）。
+ *
+ * 注：链上 proto 的 5 值枚举（UNSPECIFIED/PHYSICAL/DIGITAL/SAAS/SERVICE）与此处的 2 值
+ * 不是同一套口径, 映射规则待 xiaomu 拍板后在此处收敛。
+ */
+const VALID_PRODUCT_TYPES = ['physical', 'virtual'];
+/** 缺省 `physical`（DB 列 `NOT NULL DEFAULT 'physical'`, 与之保持一致） */
+const DEFAULT_PRODUCT_TYPE = 'physical';
+function normalizeProductType(value) {
+    return typeof value === 'string' && value !== '' ? value : DEFAULT_PRODUCT_TYPE;
+}
 function parsePagination(req) {
     const page = Math.max(1, parseInt(String(req.query.page || '1'), 10) || 1);
     const pageSize = Math.min(100, Math.max(1, parseInt(String(req.query.page_size || '20'), 10) || 20));
@@ -34,6 +54,16 @@ function parsePagination(req) {
 function createSellerProductsRouter(config) {
     const router = (0, express_1.Router)();
     const { db, enableAuth = true } = config;
+    // A1: 建品/改品要写 `product_type`, 老库没这列会直接
+    // `table store_products has no column named product_type` → 商家建品 500。
+    // `buyer-shop` 也会建这列, 但两个 router 的加载顺序不保证谁先到, 这里自建一次兜底
+    // (`ensureBuyerTables` 内部对已存在的列是 no-op, 重复调用安全)。
+    try {
+        (0, buyer_shop_1.ensureBuyerTables)(db);
+    }
+    catch (e) {
+        console.warn('[seller-products] ensureBuyerTables 失败 (建品可能受影响):', e.message);
+    }
     // Lesson #308: 全部端点走 wallet signature 鉴权
     if (enableAuth !== false) {
         router.use((0, wallet_auth_1.walletAuth)());
@@ -143,6 +173,15 @@ function createSellerProductsRouter(config) {
                     errorMessage: `status must be one of ${VALID_STATUSES.join('|')}, got ${status}`,
                 });
             }
+            // A1: 商品类型 (缺省 physical; 非法值显式 400 —— 不静默降级, 见 VALID_PRODUCT_TYPES 注释)
+            const productType = normalizeProductType(input.product_type);
+            if (!VALID_PRODUCT_TYPES.includes(productType)) {
+                return res.status(400).json({
+                    success: false,
+                    errorCode: 'INVALID_PRODUCT_TYPE',
+                    errorMessage: `product_type must be one of ${VALID_PRODUCT_TYPES.join('|')}, got ${input.product_type}`,
+                });
+            }
             // 2. 验商家注册 (Lesson #266b: 必须在 store_settings 中 active 才能创建商品)
             const sellerSetting = db
                 .prepare(`SELECT status FROM store_settings WHERE seller_address = ?`)
@@ -160,9 +199,9 @@ function createSellerProductsRouter(config) {
             const tagsJson = JSON.stringify(input.tags || []);
             db.prepare(`INSERT INTO store_products (
           id, seller_address, title, description, price_utct, stock,
-          status, category, image_url, tags, featured, sales_count,
+          status, category, image_url, tags, featured, sales_count, product_type,
           created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?)`).run(productId, sellerAddress, input.title, input.description || '', input.price_utct, input.stock, status, input.category || 'general', input.image_url || null, tagsJson, now, now);
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?, ?)`).run(productId, sellerAddress, input.title, input.description || '', input.price_utct, input.stock, status, input.category || 'general', input.image_url || null, tagsJson, productType, now, now);
             // 4. 返回 (Lesson #335: 字段一致)
             const product = db
                 .prepare(`SELECT * FROM store_products WHERE id = ?`)
@@ -268,10 +307,21 @@ function createSellerProductsRouter(config) {
             // 4. 更新
             const now = Date.now();
             const tagsJson = input.tags !== undefined ? JSON.stringify(input.tags) : row.tags;
+            // A1: 商品类型可改 (缺省沿用原值; 非法值显式 400 —— 不静默降级)
+            if (input.product_type !== undefined && !VALID_PRODUCT_TYPES.includes(input.product_type)) {
+                return res.status(400).json({
+                    success: false,
+                    errorCode: 'INVALID_PRODUCT_TYPE',
+                    errorMessage: `product_type must be one of ${VALID_PRODUCT_TYPES.join('|')}, got ${input.product_type}`,
+                });
+            }
+            const nextProductType = input.product_type !== undefined
+                ? input.product_type
+                : normalizeProductType(row.product_type);
             db.prepare(`UPDATE store_products SET
           title = ?, description = ?, price_utct = ?, category = ?,
-          image_url = ?, tags = ?, status = ?, updated_at = ?
-         WHERE id = ?`).run(input.title !== undefined ? input.title : row.title, input.description !== undefined ? input.description : row.description, input.price_utct !== undefined ? input.price_utct : row.price_utct, input.category !== undefined ? input.category : row.category, input.image_url !== undefined ? input.image_url : row.image_url, tagsJson, newStatus, now, productId);
+          image_url = ?, tags = ?, status = ?, product_type = ?, updated_at = ?
+         WHERE id = ?`).run(input.title !== undefined ? input.title : row.title, input.description !== undefined ? input.description : row.description, input.price_utct !== undefined ? input.price_utct : row.price_utct, input.category !== undefined ? input.category : row.category, input.image_url !== undefined ? input.image_url : row.image_url, tagsJson, newStatus, nextProductType, now, productId);
             // 5. 返回
             const updated = db
                 .prepare(`SELECT * FROM store_products WHERE id = ?`)
@@ -446,6 +496,8 @@ function rowToProduct(row) {
         tags,
         featured: row.featured === 1 ? 1 : 0,
         sales_count: row.sales_count,
+        // A1: 缺列的老库 / NULL 一律按 physical —— 与下单侧判定同口径
+        product_type: normalizeProductType(row.product_type),
         created_at: row.created_at,
         updated_at: row.updated_at,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trustbase-seller-backend",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "TrustBase Seller Backend (merchant edition) — 商品上链/订单/支付/质押 write API for TrustBase 保障链生态. 单卖家自托管形态: 签名 key 即卖家身份, 私钥不出门.",
   "main": "run-unified.js",
   "bin": {

package/routes/chain-writes-products.js

@@ -10,6 +10,7 @@ exports.findSlotBySku = findSlotBySku;
 exports.replayHit = replayHit;
 exports.logWrite = logWrite;
 exports.createChainWritesProductsRouter = createChainWritesProductsRouter;
+exports.mapDbProductTypeToChain = mapDbProductTypeToChain;
 /**
  * chain-writes-products.ts — 商品上链路由 (WooCommerce 商品 → 链上 x/marketplace)
  *
@@ -57,6 +58,40 @@ const CATEGORY_RE = /^[A-Za-z0-9 _-]*$/;
 /** keeper ListSKU 重复报错文案 (msg_server.go: "SKU already listed: %s") */
 exports.DUP_SKU_RE = /already listed|already exists|duplicate/i;
 const REPLAY_WINDOW_SQL = "created_at >= datetime('now', '-5 minutes')";
+/**
+ * A1 商品类型映射 (2026-10-06 xiaomu 拍板**口径 A**)。
+ *
+ * | DB (二值, 决定"要不要收货地址") | 链上 `ProductType` |
+ * |---|---|
+ * | `physical` (缺省) | `PRODUCT_TYPE_PHYSICAL` |
+ * | `virtual` | `PRODUCT_TYPE_DIGITAL` |
+ *
+ * 为什么 `virtual` 落到 `DIGITAL`: 链上另有 `SAAS` / `SERVICE` 两个非实体值, 但 xiaomu 定的是
+ * "商品类型只用于一个决策——要不要匹配收货地址", 细分语义暂不使用, 统一收敛到 `DIGITAL`。
+ *
+ * ⚠️ 非法值**显式 400** 而不是静默回落 `physical`: 静默回落会让虚拟商品被当成实体,
+ * 买家下单时被迫填收货地址 —— 静默的业务错误比 400 危险。缺省才回落 `physical`
+ * (向后兼容: 老 hook 不传该字段)。
+ *
+ * 注: `PRODUCT_TYPE_UNSPECIFIED`(=0) 不再用于新品 —— 它是 proto 的"未指定"默认值,
+ * 显式写 PHYSICAL 比留 UNSPECIFIED 更清晰, 也与 DB 侧口径一致。
+ */
+const DB_PRODUCT_TYPES = ['physical', 'virtual'];
+const DB_TO_CHAIN_PRODUCT_TYPE = {
+    physical: 'PRODUCT_TYPE_PHYSICAL',
+    virtual: 'PRODUCT_TYPE_DIGITAL',
+};
+/** 缺省 `physical`; 非法值抛 400 */
+function mapDbProductTypeToChain(value) {
+    if (value === undefined || value === null || value === '') return DB_TO_CHAIN_PRODUCT_TYPE.physical;
+    const key = String(value).toLowerCase();
+    const mapped = DB_TO_CHAIN_PRODUCT_TYPE[key];
+    if (mapped === undefined) {
+        throw new chain_writes_1.HttpError(400, 'invalid_param',
+            `product_type must be one of ${DB_PRODUCT_TYPES.join('|')}, got ${value}`);
+    }
+    return mapped;
+}
 function sha256Hex(s) {
     return crypto_1.default.createHash('sha256').update(s, 'utf8').digest('hex');
 }
@@ -198,14 +233,25 @@ function createChainWritesProductsRouter(deps) {
             const imageUrls = assertImageUrls(b.image_urls);
             const category = assertCategory(b.category);
             const skuId = `${assertSkuPrefix(b.sku_prefix)}-${wpPostId}`;
+            // A1 (2026-10-06 xiaomu 拍板口径 A): DB 二值 physical/virtual → 链上 5 值枚举。
+            // 选项 A 的映射: virtual → PRODUCT_TYPE_DIGITAL (数字产品);
+            // 其余一律 PHYSICAL。链上 DIGITAL/SAAS/SERVICE 的细分语义**暂不使用**
+            // (xiaomu: "商品类型只用于一个决策——要不要匹配收货地址")。
+            // ⚠️ 这只是 `MsgListSKU` 的链上字段; DB 侧仍是二值, 两侧靠本函数收敛。
+            const chainProductType = mapDbProductTypeToChain(b.product_type);
             // content_hash: sha256(JSON) 的 raw bytes → proto JSON bytes 字段要 base64
+            // 2026-10-06: product_type **不进 content_hash** —— 它是链上独立的枚举字段,
+            //   已由 MsgListSKU.product_type 承载; 塞进内容哈希会改变**已上架商品**的链上锚定,
+            //   代价大于收益。xiao mu 未要求, 保守处理 (见 A1 设计文档 §7.4)。
             const contentHashHex = sha256Hex(JSON.stringify({
                 title, description, image_urls: imageUrls, category, price_usd_cents: priceUsdCents,
             }));
             const contentHashB64 = Buffer.from(contentHashHex, 'hex').toString('base64');
+            // payload_hash: 幂等键。2026-10-06 **必须包含 product_type** ——
+            //   否则商家改商品类型后重发同一请求会被 replayHit 判成重放, 改了不生效。
             const payloadHash = sha256Hex(JSON.stringify({
                 wp_post_id: wpPostId, title, description, price_usd_cents: priceUsdCents,
-                stock, image_urls: imageUrls, category,
+                stock, image_urls: imageUrls, category, product_type: chainProductType,
             }));
             // 幂等短路: 完全相同 payload 5 分钟内重放 → 返回上次 txhash, 不再发链
             // (list/add_stock 两个 key 都查: 上次可能走了重复转 AddStock 路径)
@@ -228,7 +274,7 @@ function createChainWritesProductsRouter(deps) {
                 stake_per_unit: process.env.CHAIN_STAKE_PER_UNIT || '1000000',
                 cdn_url: '',
                 p2p_endpoint: process.env.P2P_ENDPOINT || '',
-                product_type: 'PRODUCT_TYPE_UNSPECIFIED', // proto 默认值 0 (实体物品)
+                product_type: chainProductType, // 2026-10-06: 不再写死 (见 mapDbProductTypeToChain)
             };
             let result = await sendTxAs(c, addr, [listMsg]);
             let action = 'list';

package/test-product-type-chain.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * test-product-type-chain.js — A1 **链上上架**侧 (2026-10-06, xiaomu 拍板口径 A)
+ * node --test test-product-type-chain.js
+ *
+ * 覆盖 `routes/chain-writes-products.js` 的 DB→链上枚举映射, 以及两个哈希的取舍:
+ *
+ *   1. `physical` → `PRODUCT_TYPE_PHYSICAL` (缺省也是它, 向后兼容老 hook)
+ *   2. `virtual`  → `PRODUCT_TYPE_DIGITAL`   (口径 A: 细分语义暂不使用)
+ *   3. 大小写不敏感
+ *   4. 非法值 / 链上枚举名 (`saas`/`digital`) → **显式 400**, 不静默回落 physical
+ *      ⚠️ 静默回落会让虚拟商品被当实体, 买家被迫填收货地址
+ *   5. `payload_hash` **含** product_type ⇒ 改类型后不会被幂等短路
+ *   6. `content_hash` **不含** product_type ⇒ 不改变已上架商品的链上锚定
+ *
+ * 本文件不碰真链: 只测纯函数 + 用源码结构断言两个哈希的取舍 (口径 A 的关键决策点)。
+ */
+const test = require("node:test");
+const assert = require("node:assert");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const { mapDbProductTypeToChain } = require("./routes/chain-writes-products");
+
+const SRC = fs.readFileSync(path.join(__dirname, "routes/chain-writes-products.js"), "utf8");
+
+test("口径 A 映射: physical → PRODUCT_TYPE_PHYSICAL", () => {
+    assert.strictEqual(mapDbProductTypeToChain("physical"), "PRODUCT_TYPE_PHYSICAL");
+});
+
+test("口径 A 映射: 缺省 → PRODUCT_TYPE_PHYSICAL (向后兼容老 hook 不传该字段)", () => {
+    assert.strictEqual(mapDbProductTypeToChain(undefined), "PRODUCT_TYPE_PHYSICAL");
+    assert.strictEqual(mapDbProductTypeToChain(null), "PRODUCT_TYPE_PHYSICAL");
+    assert.strictEqual(mapDbProductTypeToChain(""), "PRODUCT_TYPE_PHYSICAL");
+});
+
+test("口径 A 映射: virtual → PRODUCT_TYPE_DIGITAL (不是 SAAS/SERVICE)", () => {
+    assert.strictEqual(mapDbProductTypeToChain("virtual"), "PRODUCT_TYPE_DIGITAL");
+});
+
+test("口径 A 映射: 大小写不敏感", () => {
+    assert.strictEqual(mapDbProductTypeToChain("VIRTUAL"), "PRODUCT_TYPE_DIGITAL");
+    assert.strictEqual(mapDbProductTypeToChain("Physical"), "PRODUCT_TYPE_PHYSICAL");
+});
+
+test("口径 A 映射: 链上枚举名当入参 → 显式抛错, 不静默回落", () => {
+    // 这三个是链上 proto 的值, 不是 DB 的值 —— 直接传进来必须报错, 否则会静默变实体
+    for (const bad of ["saas", "digital", "service", "PRODUCT_TYPE_SAAS"]) {
+        assert.throws(() => mapDbProductTypeToChain(bad), (err) => {
+            assert.match(err.message, /product_type must be one of physical\|virtual/);
+            return true;
+        }, `输入 ${bad} 应当抛错`);
+    }
+});
+
+test("幂等键 payload_hash 含 product_type (改类型不会被重放短路)", () => {
+    const m = SRC.match(/const payloadHash = sha256Hex\(JSON\.stringify\(\{([^}]*)\}\)\)/);
+    assert.ok(m, "应能定位到 payloadHash 计算块");
+    assert.match(m[1], /product_type/, "payload_hash 必须含 product_type, 否则改类型会被幂等当重放");
+});
+
+test("content_hash 不含 product_type (不改变已上架商品的链上锚定)", () => {
+    const m = SRC.match(/const contentHashHex = sha256Hex\(JSON\.stringify\(\{([^}]*)\}\)\)/);
+    assert.ok(m, "应能定位到 contentHash 计算块");
+    assert.doesNotMatch(m[1], /product_type/,
+        "content_hash 不应含 product_type —— 会改变已上架商品的链上内容哈希");
+});
+
+test("上架 msg 不再写死 PRODUCT_TYPE_UNSPECIFIED", () => {
+    assert.doesNotMatch(SRC, /product_type:\s*'PRODUCT_TYPE_UNSPECIFIED'/,
+        "应已改为走 mapDbProductTypeToChain");
+    assert.match(SRC, /product_type:\s*chainProductType/);
+});

package/test-product-type-write.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * test-product-type-write.js — A1 **写入端**离线单测 (2026-10-06 补)
+ * node --test test-product-type-write.js
+ *
+ * ## 为什么单独一个文件
+ *
+ * 原 `test-product-type.js` 的 5 个用例**全部直接 INSERT 数据库**再打下单接口,
+ * 没有一个走过**建品接口**。于是"商家建品时无法指定 product_type"这条断链
+ * 当时完全测不出来 —— 单测全绿,真实链路上 `virtual` 却永远写不进去。
+ *
+ * 本文件专门覆盖写入端,让这种断链以后能被测出来。
+ *
+ * 覆盖:
+ *   1. 建品传 `product_type: 'virtual'` → 真落库 (断链一回归)
+ *   2. 建品不传 → 默认 `physical` (向后兼容, 老客户端不受影响)
+ *   3. 建品传**非法值** (如链上枚举名 `saas`) → 400 INVALID_PRODUCT_TYPE
+ *      ⚠️ 必须报错而不是静默降级成 physical: 下单侧是 `=== 'virtual' ? virtual : physical`,
+ *         静默降级会让买虚拟商品的买家被迫填收货地址
+ *   4. 改品 `product_type` → 可改 (physical ⇄ virtual)
+ *   5. 改品不传该字段 → 沿用原值, 不被意外重置
+ *   6. 响应体回显 `product_type`
+ *   7. 老库缺 `product_type` 列时 rowToProduct 仍返回 `physical` (不炸)
+ *
+ * 离��: `:memory:` 库 + express, `enableAuth: false` 绕开 wallet 签名 (本文件只测参数校验与落库)。
+ */
+const test = require("node:test");
+const assert = require("node:assert");
+const express = require("express");
+const Database = require("better-sqlite3");
+
+const { createSellerProductsRouter } = require("./api/seller-products");
+
+const SELLER = "tct1" + "s".repeat(38);
+const NOW_MS = Date.now();
+
+/** A1 迁移后的 schema (含 product_type 列) */
+function seed(db) {
+    db.exec(`
+CREATE TABLE store_products (
+  id TEXT PRIMARY KEY, seller_address TEXT NOT NULL, title TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '', price_utct INTEGER NOT NULL,
+  stock INTEGER NOT NULL DEFAULT 0, status TEXT NOT NULL DEFAULT 'draft',
+  category TEXT DEFAULT 'general', image_url TEXT, tags TEXT DEFAULT '[]',
+  featured INTEGER NOT NULL DEFAULT 0, sales_count INTEGER NOT NULL DEFAULT 0,
+  product_type TEXT NOT NULL DEFAULT 'physical',
+  created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+);
+CREATE TABLE store_settings (seller_address TEXT PRIMARY KEY, status TEXT NOT NULL);
+`);
+    db.prepare("INSERT INTO store_settings (seller_address, status) VALUES (?, 'active')").run(SELLER);
+}
+
+/** 老库: 没有 product_type 列 (验证向后兼容不炸) */
+function seedLegacyNoColumn(db) {
+    db.exec(`
+CREATE TABLE store_products (
+  id TEXT PRIMARY KEY, seller_address TEXT NOT NULL, title TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '', price_utct INTEGER NOT NULL,
+  stock INTEGER NOT NULL DEFAULT 0, status TEXT NOT NULL DEFAULT 'draft',
+  category TEXT DEFAULT 'general', image_url TEXT, tags TEXT DEFAULT '[]',
+  featured INTEGER NOT NULL DEFAULT 0, sales_count INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+);
+CREATE TABLE store_settings (seller_address TEXT PRIMARY KEY, status TEXT NOT NULL);
+`);
+    db.prepare("INSERT INTO store_settings (seller_address, status) VALUES (?, 'active')").run(SELLER);
+    // 前置: 确认这张表确实没有 product_type 列（boot 里 router 会把它补上）
+    assert.ok(
+        !db.prepare("PRAGMA table_info(store_products)").all().map((c) => c.name).includes("product_type"),
+        "前置失败: seedLegacyNoColumn 建出的表不该有 product_type 列"
+    );
+}
+
+async function post(port, body) {
+    const r = await fetch(`http://127.0.0.1:${port}/api/seller/products`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    return { status: r.status, body: await r.json() };
+}
+
+async function patch(port, id, body) {
+    const r = await fetch(`http://127.0.0.1:${port}/api/seller/products/${id}`, {
+        method: "PUT",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    return { status: r.status, body: await r.json() };
+}
+
+/** 起服务并确保端口就绪 (app.listen(0) 之后 address() 才可用) */
+async function boot(seedFn) {
+    const db = new Database(":memory:");
+    seedFn(db);
+    const app = express();
+    app.use(express.json());
+    app.use((req, _res, next) => {
+        req.walletAddress = SELLER;
+        next();
+    });
+    app.use("/api/seller", createSellerProductsRouter({ db, enableAuth: false }));
+    const srv = await new Promise((resolve) => {
+        const s = app.listen(0, "127.0.0.1", () => resolve(s));
+    });
+    return { db, port: srv.address().port, close: () => srv.close() };
+}
+
+test("A1 写入端: 建品能指定 virtual —— 断链一回归", async () => {
+    const { db, port, close } = await boot(seed);
+    try {
+        const r = await post(port, { title: "技能商店基础版", price_utct: 1000000, stock: 99, product_type: "virtual" });
+        assert.strictEqual(r.status, 201, "建品应成功");
+        assert.strictEqual(r.body.product.product_type, "virtual", "响应体应回显 virtual");
+
+        // 真落库核验 (不能只看响应)
+        const row = db.prepare("SELECT product_type FROM store_products WHERE id = ?").get(r.body.product.id);
+        assert.strictEqual(row.product_type, "virtual", "DB 里必须真的写进去了");
+    } finally { close(); }
+});
+
+test("A1 写入端: 不传 product_type → 默认 physical (向后兼容)", async () => {
+    const { db, port, close } = await boot(seed);
+    try {
+        const r = await post(port, { title: "云南滇红 250g", price_utct: 2500000, stock: 10 });
+        assert.strictEqual(r.status, 201);
+        assert.strictEqual(r.body.product.product_type, "physical");
+        const row = db.prepare("SELECT product_type FROM store_products WHERE id = ?").get(r.body.product.id);
+        assert.strictEqual(row.product_type, "physical");
+    } finally { close(); }
+});
+
+test("A1 写入端: 非法 product_type → 400, 绝不静默降级成 physical", async () => {
+    const { db, port, close } = await boot(seed);
+    try {
+        // 链上 proto 的枚举名 —— 属于 §7.2 待拍板的口径冲突, 现在必须明确拒绝而不是静默吞掉
+        const r = await post(port, { title: "订阅服务", price_utct: 100, stock: 1, product_type: "saas" });
+        assert.strictEqual(r.status, 400, "非法值必须 400");
+        assert.strictEqual(r.body.errorCode, "INVALID_PRODUCT_TYPE");
+        // 关键: 不能建出商品来
+        const n = db.prepare("SELECT COUNT(*) c FROM store_products").get().c;
+        assert.strictEqual(n, 0, "被拒的商品不应落库");
+    } finally { close(); }
+});
+
+test("A1 写入端: product_type 可改 (physical ⇄ virtual)", async () => {
+    const { db, port, close } = await boot(seed);
+    try {
+        const created = await post(port, { title: "手作陶壶", price_utct: 8800000, stock: 5, product_type: "physical" });
+        const id = created.body.product.id;
+
+        const r1 = await patch(port, id, { product_type: "virtual" });
+        assert.strictEqual(r1.status, 200);
+        assert.strictEqual(r1.body.product.product_type, "virtual");
+        assert.strictEqual(
+            db.prepare("SELECT product_type FROM store_products WHERE id = ?").get(id).product_type,
+            "virtual"
+        );
+
+        const r2 = await patch(port, id, { product_type: "physical" });
+        assert.strictEqual(r2.body.product.product_type, "physical");
+    } finally { close(); }
+});
+
+test("A1 写入端: 改品不传该字段 → 沿用原值, 不被重置", async () => {
+    const { db, port, close } = await boot(seed);
+    try {
+        const created = await post(port, { title: "入门课程", price_utct: 5000, stock: 9, product_type: "virtual" });
+        const id = created.body.product.id;
+        // 只改标题, 不碰类型
+        const r = await patch(port, id, { title: "课程 (改名)" });
+        assert.strictEqual(r.status, 200);
+        assert.strictEqual(r.body.product.product_type, "virtual", "类型不应被意外重置成 physical");
+    } finally { close(); }
+});
+
+test("A1 写入端: 改品传非法值 → 400, 原值不变", async () => {
+    const { db, port, close } = await boot(seed);
+    try {
+        const created = await post(port, { title: "插件工具包", price_utct: 1000, stock: 3, product_type: "virtual" });
+        const id = created.body.product.id;
+        const r = await patch(port, id, { product_type: "digital" });
+        assert.strictEqual(r.status, 400);
+        assert.strictEqual(r.body.errorCode, "INVALID_PRODUCT_TYPE");
+        assert.strictEqual(
+            db.prepare("SELECT product_type FROM store_products WHERE id = ?").get(id).product_type,
+            "virtual",
+            "被拒的修改不应生效"
+        );
+    } finally { close(); }
+});
+
+test("A1 写入端: 老库缺 product_type 列 → 自动补列, 建品成功 (不是 500)", async () => {
+    const { db, port, close } = await boot(seedLegacyNoColumn);
+    try {
+        // 修复证据: router 初始化时 ensureBuyerTables 已把列补上
+        const cols = db.prepare("PRAGMA table_info(store_products)").all().map((c) => c.name);
+        assert.ok(cols.includes("product_type"), "router 应已自动补上 product_type 列");
+
+        const r = await post(port, { title: "老库商品", price_utct: 100, stock: 1, product_type: "virtual" });
+        // router 初始化时 ensureBuyerTables 应已把列补上 —— 老库商家不该被 500 拦住
+        assert.strictEqual(r.status, 201, `老库建品应成功, 实得 ${r.status}: ${JSON.stringify(r.body)}`);
+        assert.strictEqual(r.body.product.product_type, "virtual");
+
+        // 不传类型时也应回落 physical, 而不是因为补列前的 NULL 出问题
+        const r2 = await post(port, { title: "老库商品二", price_utct: 100, stock: 1 });
+        assert.strictEqual(r2.status, 201);
+        assert.strictEqual(r2.body.product.product_type, "physical");
+    } finally { close(); }
+});