joey5628/atlas-seller-kit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(edit): 类目问题修改

Browse Source
This commit is contained in:
R524809
2026-09-11 10:36:25 +08:00
parent 05a00d46b9
commit 2c4e94ab3d
11 changed files with 869 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/api/src/product-editor/product-editor.service.ts
+212
View File
@@ -251,6 +251,43 @@ export class ProductEditorService {
ORDER BY is_default DESC, name, id`,
[platformId],
);
const media = await transaction.query<{
listing_id: string;
asset_id: string;
content_type: 'image/jpeg' | 'image/png' | 'image/webp';
byte_size: string;
width_px: number | null;
height_px: number | null;
source_url: string | null;
}>(
`SELECT m.listing_id, m.asset_id, a.content_type, a.byte_size::text,
a.width_px, a.height_px, min(t.source_url) AS source_url
FROM atlas.product_variant_listing_media m
JOIN atlas.media_assets a ON a.id = m.asset_id
LEFT JOIN atlas.collection_asset_transfers t
ON t.asset_id = m.asset_id AND t.product_id = $2
WHERE m.profile_id = $1
GROUP BY m.id, m.listing_id, m.asset_id, a.content_type,
a.byte_size, a.width_px, a.height_px
ORDER BY m.listing_id, m.sort_order, m.id`,
[profile.id, productId],
);
const mediaByListing = new Map<
string,
ProductEditorSnapshot['variants'][number]['media']
>();
for (const item of media.rows) {
const items = mediaByListing.get(item.listing_id) ?? [];
items.push({
asset_id: item.asset_id,
content_type: item.content_type,
byte_size: Number(item.byte_size),
width_px: item.width_px,
height_px: item.height_px,
source_url: item.source_url,
});
mediaByListing.set(item.listing_id, items);
}
const listingCounts = await transaction.query<{
total: string;
imported: string;
@@ -336,6 +373,7 @@ export class ProductEditorService {
list_price: variant.list_price,
currency_code: variant.currency_code,
},
media: mediaByListing.get(variant.listing_id) ?? [],
}));
return {
collection_item_id: product.collection_item_id,
@@ -845,10 +883,18 @@ export class ProductEditorService {
id: string;
}> = [];
const retainedIds: string[] = [];
const variantMedia: Array<{
variantId: string;
assetIds: string[];
}> = [];
for (let index = 0; index < input.variants.length; index += 1) {
const variant = input.variants[index];
if (variant.id) {
retainedIds.push(variant.id);
variantMedia.push({
variantId: variant.id,
assetIds: variant.media_asset_ids,
});
await transaction.query(
`UPDATE atlas.product_variants
SET display_name = $1, source_sku = $2, purchase_cost_cny = $3,
@@ -959,6 +1005,10 @@ export class ProductEditorService {
);
const id = inserted.rows[0].id;
retainedIds.push(id);
variantMedia.push({
variantId: id,
assetIds: variant.media_asset_ids,
});
createdVariants.push({
client_key: variant.client_key!,
id,
@@ -1004,6 +1054,11 @@ export class ProductEditorService {
attributes: input.attributes,
retainedVariantIds: retainedIds,
});
await this.persistListingMedia(transaction, {
product,
profile,
variants: variantMedia,
});
return {
status: 200,
body: {
@@ -1045,6 +1100,163 @@ export class ProductEditorService {
);
}
/**
* Persist final image order only after every supplied asset has passed the
* product/SKU provenance check. A completed transfer is the bridge from
* an untrusted source URL to an Atlas-owned media asset; callers cannot
* attach arbitrary workspace assets to a listing.
*/
private async persistListingMedia(
transaction: DatabaseTransaction,
input: {
product: ProductRow;
profile: ProfileRow;
variants: Array<{ variantId: string; assetIds: string[] }>;
},
) {
const variantIds = input.variants.map((variant) => variant.variantId);
const listings = await transaction.query<{
id: string;
product_variant_id: string;
}>(
`SELECT id, product_variant_id
FROM atlas.product_variant_platform_listings
WHERE profile_id = $1 AND product_variant_id = ANY($2::uuid[])`,
[input.profile.id, variantIds],
);
if (listings.rows.length !== input.variants.length)
throw new ApiError(
409,
'LISTING_CONTEXT_CHANGED',
'SKU 发布记录已变化，请重新加载编辑器',
);
const listingByVariant = new Map(
listings.rows.map((listing) => [listing.product_variant_id, listing]),
);
const assetIds = [
...new Set(input.variants.flatMap((variant) => variant.assetIds)),
];
const assets = assetIds.length
? await transaction.query<{
id: string;
content_type: string;
byte_size: string;
width_px: number | null;
height_px: number | null;
}>(
`SELECT id, content_type, byte_size::text, width_px, height_px
FROM atlas.media_assets WHERE id = ANY($1::uuid[])`,
[assetIds],
)
: { rows: [] };
const assetById = new Map(assets.rows.map((asset) => [asset.id, asset]));
const existing = await transaction.query<{
product_variant_id: string;
asset_id: string;
}>(
`SELECT l.product_variant_id, m.asset_id
FROM atlas.product_variant_listing_media m
JOIN atlas.product_variant_platform_listings l ON l.id = m.listing_id
WHERE m.profile_id = $1 AND m.product_variant_id = ANY($2::uuid[])`,
[input.profile.id, variantIds],
);
const existingByVariant = new Map<string, Set<string>>();
for (const item of existing.rows) {
const ids = existingByVariant.get(item.product_variant_id) ?? new Set();
ids.add(item.asset_id);
existingByVariant.set(item.product_variant_id, ids);
}
const candidates = assetIds.length
? await transaction.query<{
asset_id: string;
source_variant_id: string | null;
}>(
`SELECT DISTINCT t.asset_id, t.source_variant_id
FROM atlas.collection_asset_transfers t
WHERE t.collection_item_id = $1 AND t.product_id = $2
AND t.source_snapshot_revision = $3
AND t.status = 'succeeded'
AND t.asset_id = ANY($4::uuid[])`,
[
input.product.collection_item_id,
input.product.id,
input.product.source_snapshot_revision,
assetIds,
],
)
: { rows: [] };
const candidateVariants = new Map<string, Set<string | null>>();
for (const candidate of candidates.rows) {
const variants = candidateVariants.get(candidate.asset_id) ?? new Set();
variants.add(candidate.source_variant_id);
candidateVariants.set(candidate.asset_id, variants);
}
for (const variant of input.variants) {
for (const [index, assetId] of variant.assetIds.entries()) {
const asset = assetById.get(assetId);
const dimensionsKnown =
asset?.width_px !== null && asset?.height_px !== null;
if (
!asset ||
!['image/jpeg', 'image/png', 'image/webp'].includes(
asset.content_type,
) ||
Number(asset.byte_size) > 20 * 1024 * 1024 ||
!dimensionsKnown ||
asset.width_px! > 10_000 ||
asset.height_px! > 10_000
)
throw new ApiError(
422,
'LISTING_MEDIA_INVALID',
'SKU 图片必须是已校验的 JPG、PNG 或 WebP，且不超过 20MB / 10000px',
);
if (
index === 0 &&
Math.min(asset.width_px!, asset.height_px!) < 700
)
throw new ApiError(
422,
'LISTING_MAIN_IMAGE_TOO_SMALL',
'短边小于 700px 的图片不能作为 SKU 主图',
);
if (existingByVariant.get(variant.variantId)?.has(assetId))
continue;
const allowedFor = candidateVariants.get(assetId);
if (!allowedFor?.has(null) && !allowedFor?.has(variant.variantId))
throw new ApiError(
422,
'LISTING_MEDIA_NOT_SELECTABLE',
'只能选择当前采集快照中该 SKU 或商品通用候选已转存的图片',
);
}
}
const listingIds = listings.rows.map((listing) => listing.id);
await transaction.query(
`DELETE FROM atlas.product_variant_listing_media
WHERE listing_id = ANY($1::uuid[])`,
[listingIds],
);
for (const variant of input.variants) {
const listing = listingByVariant.get(variant.variantId)!;
for (const [sortOrder, assetId] of variant.assetIds.entries()) {
await transaction.query(
`INSERT INTO atlas.product_variant_listing_media
(workspace_id, product_id, profile_id, listing_id, product_variant_id, asset_id, sort_order)
VALUES (current_setting('app.workspace_id')::uuid, $1, $2, $3, $4, $5, $6)`,
[
input.product.id,
input.profile.id,
listing.id,
variant.variantId,
assetId,
sortOrder,
],
);
}
}
}
private async persistDynamicAttributes(
transaction: DatabaseTransaction,
input: {
apps/api/test/product-editor.e2e.test.ts
+101 -1
View File
@@ -126,6 +126,10 @@ describe('商品编辑 M3.0–M3.3 HTTP 集成测试', () => {
'DELETE FROM atlas.product_attributes WHERE workspace_id = $1',
[workspaceId],
);
await tx.query(
'DELETE FROM atlas.product_variant_listing_media WHERE workspace_id = $1',
[workspaceId],
);
await tx.query(
'DELETE FROM atlas.product_variant_platform_listings WHERE workspace_id = $1',
[workspaceId],
@@ -157,6 +161,9 @@ describe('商品编辑 M3.0–M3.3 HTTP 集成测试', () => {
await tx.query('DELETE FROM atlas.stores WHERE workspace_id = $1', [
workspaceId,
]);
await tx.query('DELETE FROM atlas.media_assets WHERE workspace_id = $1', [
workspaceId,
]);
});
await database.query(
'DELETE FROM atlas.workspace_memberships WHERE user_id = $1',
@@ -1058,7 +1065,7 @@ describe('商品编辑 M3.0–M3.3 HTTP 集成测试', () => {
await database.workspaceTransaction(workspaceId, async (tx) => {
await tx.query(
`UPDATE atlas.collection_items
SET source_platform_id = $1,
SET source_kind = 'platform', source_platform_id = $1,
normalized_payload = $2::jsonb
WHERE id = $3`,
[
@@ -1193,4 +1200,97 @@ describe('商品编辑 M3.0–M3.3 HTTP 集成测试', () => {
);
});
});
it('M3.6 仅允许当前 SKU 已转存候选作为有序正式素材', async () => {
const before = await request(`/api/products/${first.productId}/editor`, {
headers: headers({ 'X-Atlas-Platform-Id': platformId }),
});
const variant = before.body.data.variants[0];
const asset = await database.workspaceTransaction(workspaceId, async (tx) => {
const created = await tx.query<{ id: string }>(
`INSERT INTO atlas.media_assets
(workspace_id, storage_provider, bucket, object_key, content_type,
byte_size, checksum_sha256, width_px, height_px)
VALUES (current_setting('app.workspace_id')::uuid, 'test', 'test', $1,
'image/jpeg', 1024, $2, 1200, 900)
RETURNING id`,
[`m36/${randomUUID()}.jpg`, randomUUID().replaceAll('-', '')],
);
const snapshot = await tx.query<{ source_snapshot_revision: string }>(
`SELECT source_snapshot_revision::text FROM atlas.collection_items WHERE id = $1`,
[first.collectionItemId],
);
await tx.query(
`INSERT INTO atlas.collection_asset_transfers
(workspace_id, collection_item_id, product_id, source_variant_id, role,
source_url, status, asset_id, source_snapshot_revision, completed_at)
VALUES (current_setting('app.workspace_id')::uuid, $1, $2, $3,
'source_sku', 'https://example.test/m36.jpg', 'succeeded', $4, $5, now())`,
[
first.collectionItemId,
first.productId,
variant.id,
created.rows[0].id,
snapshot.rows[0].source_snapshot_revision,
],
);
return created.rows[0].id;
});
const payload = {
ai_source_material: before.body.data.source_material,
ai_source_overridden_fields:
before.body.data.source_material_state.overridden_fields,
common: {
...before.body.data.product.common,
default_physical_spec: before.body.data.product.default_physical_spec,
default_package_spec: before.body.data.product.default_package_spec,
},
profile: {
target_store_id: before.body.data.profile.target_store.id,
fulfillment: before.body.data.profile.fulfillment,
title: before.body.data.profile.title,
description: before.body.data.profile.description,
tags: before.body.data.profile.tags,
store_product_category_id: before.body.data.profile.category.id,
category_source: before.body.data.profile.category.source,
},
attributes: before.body.data.attributes.map((attribute: any) => ({
scope: attribute.scope,
variant_id: attribute.variant_id,
platform_attribute_id: attribute.platform_attribute_id,
complex_id: attribute.complex_id,
values: attribute.values,
language_code: attribute.language_code,
source: attribute.source,
confirmation_status: attribute.confirmation_status,
})),
variants: before.body.data.variants.map((item: any) => ({
id: item.id,
client_key: null,
copy_from_variant_id: null,
display_name: item.display_name,
source_sku: item.source_sku,
specification_values: item.specification_values,
purchase_cost_cny: item.purchase_cost_cny,
physical_spec: item.physical_spec,
package_spec: item.package_spec,
offer_id: item.listing.offer_id,
media_asset_ids: item.id === variant.id ? [asset] : [],
})),
};
const saved = await request(`/api/products/${first.productId}/editor-draft`, {
method: 'PUT',
headers: headers({
'X-Atlas-Platform-Id': platformId,
'Idempotency-Key': randomUUID(),
'If-Match': `"${before.body.data.product.revision}:${before.body.data.profile.revision}"`,
}),
body: JSON.stringify(payload),
});
assert.equal(saved.response.status, 200);
const after = await request(`/api/products/${first.productId}/editor`, {
headers: headers({ 'X-Atlas-Platform-Id': platformId }),
});
assert.deepEqual(after.body.data.variants[0].media.map((item: any) => item.asset_id), [asset]);
});
});
apps/api/test/worker-catalog-scheduler.e2e.test.ts
+199
View File
@@ -0,0 +1,199 @@
import assert from 'node:assert/strict';
import { randomUUID } from 'node:crypto';
import type { AddressInfo } from 'node:net';
import type { Database } from '@atlas/database';
import type { NestExpressApplication } from '@nestjs/platform-express';
import { afterAll, beforeAll, describe, it } from 'vitest';
import { DATABASE } from '../src/database/database.module.js';
import { createApplication } from '../src/main.js';
import { OutboxDispatcher } from '../../worker/src/outbox-dispatcher.js';
import { scheduleStoreCategoryTreeSync } from '../../worker/src/store-category-tree-scheduler.js';
let app: NestExpressApplication;
let database: Database;
let baseUrl = '';
let workspaceId = '';
let userId = '';
let token = '';
let platformId = '';
let storeId = '';
let secretId = '';
async function request(path: string, init: RequestInit = {}) {
const response = await fetch(`${baseUrl}${path}`, {
...init,
headers: { 'Content-Type': 'application/json', ...init.headers },
});
return { response, body: (await response.json()) as any };
}
async function scheduleWithStoreLock() {
return database.workspaceTransaction(workspaceId, async (transaction) => {
await transaction.query(
'SELECT id FROM atlas.stores WHERE id = $1 FOR UPDATE',
[storeId],
);
return scheduleStoreCategoryTreeSync(transaction, {
storeId,
platformId,
secretId,
});
});
}
describe('门店类目树 Worker 调度集成测试', () => {
beforeAll(async () => {
Object.assign(process.env, {
NODE_ENV: 'test',
SWAGGER_ENABLED: 'false',
AUTH_REGISTER_IP_LIMIT: '100',
AUTH_REGISTER_EMAIL_LIMIT: '100',
});
const created = await createApplication();
app = created.app;
database = app.get<Database>(DATABASE);
await app.listen(0, '127.0.0.1');
baseUrl = `http://127.0.0.1:${(app.getHttpServer().address() as AddressInfo).port}`;
const registration = await request('/api/auth/register', {
method: 'POST',
body: JSON.stringify({
email: `catalog-worker-${randomUUID()}@example.test`,
password: 'correct-horse-battery-staple-123',
password_confirmation: 'correct-horse-battery-staple-123',
}),
});
assert.equal(registration.response.status, 201);
workspaceId = registration.body.data.workspace.id;
userId = registration.body.data.user.id;
token = registration.body.data.access_token;
const platforms = await request('/api/platforms', {
headers: { Authorization: `Bearer ${token}` },
});
platformId = platforms.body.data[0].id;
const seeded = await database.workspaceTransaction(workspaceId, async (tx) => {
const store = await tx.query<{ id: string }>(
`INSERT INTO atlas.stores
(workspace_id, platform_id, name, platform_client_id, currency_code,
is_default, status, credential_status)
VALUES (current_setting('app.workspace_id')::uuid, $1, '类目 Worker 测试店',
$2, 'RUB', true, 'active', 'valid')
RETURNING id`,
[platformId, `catalog-worker-${randomUUID()}`],
);
const secret = await tx.query<{ id: string }>(
`INSERT INTO atlas.store_secrets
(workspace_id, store_id, kind, secret_ciphertext, secret_nonce,
encryption_key_version, fingerprint, status)
VALUES (current_setting('app.workspace_id')::uuid, $1, 'seller_api_key',
$2, $3, 'test', $4, 'valid')
RETURNING id`,
[
store.rows[0].id,
Buffer.from('catalog-worker-api-key-must-not-leak'),
Buffer.from('catalog-worker-nonce'),
randomUUID(),
],
);
return { storeId: store.rows[0].id, secretId: secret.rows[0].id };
});
storeId = seeded.storeId;
secretId = seeded.secretId;
});
afterAll(async () => {
await database.workspaceTransaction(workspaceId, async (tx) => {
await tx.query('DELETE FROM atlas.outbox_events WHERE workspace_id = $1', [workspaceId]);
await tx.query('DELETE FROM atlas.operations WHERE workspace_id = $1', [workspaceId]);
await tx.query('DELETE FROM atlas.store_product_categories WHERE workspace_id = $1', [workspaceId]);
await tx.query('DELETE FROM atlas.stores WHERE workspace_id = $1', [workspaceId]);
});
await database.query('DELETE FROM atlas.workspace_memberships WHERE user_id = $1', [userId]);
await database.query('DELETE FROM atlas.workspaces WHERE id = $1', [workspaceId]);
await database.query('DELETE FROM atlas.users WHERE id = $1', [userId]);
await app.close();
});
it('空缓存的并发验证只创建一个无密钥的树同步任务', async () => {
const results = await Promise.all([scheduleWithStoreLock(), scheduleWithStoreLock()]);
assert.equal(results.filter((result) => result.scheduled).length, 1);
assert.ok(results.some((result) => !result.scheduled && result.reason === 'already_queued'));
await database.workspaceTransaction(workspaceId, async (tx) => {
const events = await tx.query<{ event_payload: unknown }>(
`SELECT event_payload FROM atlas.outbox_events
WHERE aggregate_id = $1 AND event_type = 'store_category_tree_sync.requested'`,
[storeId],
);
assert.equal(events.rows.length, 1);
const payload = JSON.stringify(events.rows[0].event_payload);
assert.ok(!payload.includes('catalog-worker-api-key-must-not-leak'));
assert.ok(!payload.includes('catalog-worker-nonce'));
});
});
it('已有已同步的门店缓存时跳过 Ozon 请求调度', async () => {
await database.workspaceTransaction(workspaceId, async (tx) => {
await tx.query(
`UPDATE atlas.operations SET status = 'succeeded', completed_at = now()
WHERE kind = 'store_category_tree_sync' AND resource_id = $1`,
[storeId],
);
await tx.query(
`INSERT INTO atlas.store_product_categories
(workspace_id, store_id, platform_id, external_category_id, external_type_id,
name, path, synced_at)
VALUES (current_setting('app.workspace_id')::uuid, $1, $2,
'worker-cache', 'worker-type', '已缓存类目', '已缓存类目', now())`,
[storeId, platformId],
);
});
const result = await scheduleWithStoreLock();
assert.deepEqual(result, { scheduled: false, reason: 'cache_available' });
});
it('为 Ozon 暂时失败配置五次指数退避', async () => {
const enqueued: Array<{ name: string; options: Record<string, unknown> }> = [];
const dispatcher = new OutboxDispatcher(
{
query: async () => ({ rows: [{ id: workspaceId }] }),
workspaceTransaction: async (_workspaceId: string, work: any) =>
work({
query: async (sql: string) =>
sql.includes('RETURNING event.id')
? {
rows: [
{
id: randomUUID(),
workspace_id: workspaceId,
event_type: 'store_category_tree_sync.requested',
event_payload: {
store_id: storeId,
secret_id: secretId,
},
},
],
}
: { rows: [] },
}),
} as never,
{
add: async (name: string, _data: unknown, options: Record<string, unknown>) => {
enqueued.push({ name, options });
},
} as never,
'worker-test',
);
await dispatcher.dispatchBatch();
assert.deepEqual(enqueued, [
{
name: 'store_category_tree_sync.requested',
options: {
jobId: enqueued[0]?.options.jobId,
attempts: 5,
backoff: { type: 'exponential', delay: 5_000 },
removeOnComplete: 1_000,
removeOnFail: 1_000,
},
},
]);
});
});
apps/api/tsconfig.test.json
+1 -1
View File
@@ -1,7 +1,7 @@
{
"extends": "./tsconfig.json",
"compilerOptions": {
"rootDir": ".",
"rootDir": "..",
"noEmit": true
},
"include": ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts"]