Files
order_site/apps/backend/src/services/fulfillment/internal-sku-mapping-service.ts
T

291 lines
9.4 KiB
TypeScript

import { query, withTransaction } from '../../db/client.js'
import { canonicalizeInternalSku, containsCjk } from './internal-sku-resolver.js'
import { createHttpError } from '../../utils/http.js'
export type InternalSkuMappingMatchType =
| 'sku_code'
| 'sku_nick'
| 'out_sku_sn'
| 'spec'
| 'sku_name'
export type InternalSkuMappingCandidate = {
matchType: InternalSkuMappingMatchType
value: unknown
}
const INTERNAL_SKU_MAPPING_MATCH_TYPES = new Set<InternalSkuMappingMatchType>([
'sku_code',
'sku_nick',
'out_sku_sn',
'spec',
'sku_name',
])
export type ResolvedInternalSkuMapping = {
id: number
internalSku: string
source: string
}
export type InternalSkuMappingRow = {
id: number
provider: string
shop_id: string
match_type: InternalSkuMappingMatchType
match_value: string
internal_sku: string
priority: number
enabled: boolean
source: string
note: string
updated_at: string
}
export function normalizeInternalSkuMappingValue(value: unknown): string {
return canonicalizeInternalSku(value)
}
/**
* 按平台字段候选值查内部中文 SKU 映射。
*
* 优先级:精确 provider/shop > 全局;同范围按候选字段顺序、priority、id 升序。
* 返回 null 表示没有映射,调用方回退 manual_sku_key 生成列。
*/
export async function resolveInternalSkuMapping(input: {
provider?: string | null
shopId?: string | null
candidates: InternalSkuMappingCandidate[]
}): Promise<ResolvedInternalSkuMapping | null> {
const provider = String(input.provider || '').trim()
const shopId = String(input.shopId || '').trim()
const pairs = input.candidates
.map((candidate, candidatePriority) => ({
matchType: candidate.matchType,
matchValue: normalizeInternalSkuMappingValue(candidate.value),
candidatePriority,
}))
.filter((candidate) => candidate.matchValue !== '')
if (pairs.length === 0) return null
const result = await query<{ id: number; internal_sku: string; source: string }>(
`
SELECT m.id, m.internal_sku, m.source
FROM internal_sku_mappings m
JOIN unnest($3::text[], $4::text[], $5::int[])
AS c(match_type, match_value, candidate_priority)
ON m.match_type = c.match_type
AND canonicalize_internal_sku(m.match_value) = c.match_value
WHERE m.enabled = TRUE
AND (m.provider = '' OR m.provider = $1)
AND (m.shop_id = '' OR m.shop_id = $2)
ORDER BY
CASE WHEN m.provider = $1 AND m.shop_id = $2 THEN 0
WHEN m.provider = $1 THEN 1
WHEN m.shop_id = $2 THEN 2
ELSE 3 END,
c.candidate_priority ASC,
m.priority ASC,
m.id ASC
LIMIT 1
`,
[
provider,
shopId,
pairs.map((pair) => pair.matchType),
pairs.map((pair) => pair.matchValue),
pairs.map((pair) => pair.candidatePriority),
],
)
const row = result.rows[0]
if (!row) return null
return {
id: Number(row.id),
internalSku: canonicalizeInternalSku(row.internal_sku),
source: String(row.source || 'manual'),
}
}
export async function upsertInternalSkuMapping(input: {
provider?: string | null
shopId?: string | null
matchType: InternalSkuMappingMatchType
matchValue: string
internalSku: string
priority?: number
source?: string
note?: string
enabled?: boolean
}): Promise<number> {
const provider = String(input.provider || '').trim()
const shopId = String(input.shopId || '').trim()
if (!INTERNAL_SKU_MAPPING_MATCH_TYPES.has(input.matchType)) {
throw createHttpError('映射类型无效', {
statusCode: 400,
errorCode: 'internal_sku_mapping_type_invalid',
})
}
const matchValue = normalizeInternalSkuMappingValue(input.matchValue)
const internalSku = canonicalizeInternalSku(input.internalSku)
const priority = Number.isFinite(Number(input.priority)) ? Number(input.priority) : 100
const source = String(input.source || 'manual').trim() || 'manual'
const note = String(input.note || '').trim()
const enabled = input.enabled !== false
if (!matchValue || !internalSku || !containsCjk(internalSku)) {
throw createHttpError('内部 SKU 和匹配值不能为空,且内部 SKU 必须包含中文', {
statusCode: 400,
errorCode: 'internal_sku_mapping_invalid',
})
}
return withTransaction(async (client) => {
const existing = await client.query<{ id: number }>(
`SELECT id FROM internal_sku_mappings
WHERE provider = $1 AND shop_id = $2 AND match_type = $3
AND canonicalize_internal_sku(match_value) = $4
ORDER BY id
FOR UPDATE`,
[provider, shopId, input.matchType, matchValue],
)
if (existing.rows.length > 1) {
throw createHttpError('同一平台/店铺/字段存在多条规范化重复映射', {
statusCode: 409,
errorCode: 'internal_sku_mapping_ambiguous',
})
}
const existingId = Number(existing.rows[0]?.id || 0)
const result = existingId
? await client.query<{ id: number }>(
`UPDATE internal_sku_mappings
SET match_value = $2, internal_sku = $3, priority = $4,
enabled = $5, source = $6, note = $7, updated_at = NOW()
WHERE id = $1
RETURNING id`,
[existingId, matchValue, internalSku, priority, enabled, source, note],
)
: await client.query<{ id: number }>(
`INSERT INTO internal_sku_mappings (
provider, shop_id, match_type, match_value, internal_sku,
priority, enabled, source, note, created_at, updated_at
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW(), NOW())
RETURNING id`,
[
provider,
shopId,
input.matchType,
matchValue,
internalSku,
priority,
enabled,
source,
note,
],
)
return Number(result.rows[0]?.id || 0)
})
}
export async function listInternalSkuMappingsPage(input: {
keyword?: string
provider?: string
shopId?: string
matchType?: string
page?: number
pageSize?: number
}): Promise<{ items: InternalSkuMappingRow[]; total: number; page: number; pageSize: number }> {
const page = Math.max(1, Math.trunc(Number(input.page) || 1))
const pageSize = Math.min(200, Math.max(1, Math.trunc(Number(input.pageSize) || 30)))
const params: unknown[] = []
const clauses: string[] = []
const keyword = String(input.keyword || '').trim()
if (keyword) {
params.push(`%${keyword}%`)
clauses.push(
`(match_value ILIKE $${params.length} OR internal_sku ILIKE $${params.length} OR note ILIKE $${params.length})`,
)
}
if (input.provider) {
params.push(String(input.provider).trim())
clauses.push(`provider = $${params.length}`)
}
if (input.shopId) {
params.push(String(input.shopId).trim())
clauses.push(`shop_id = $${params.length}`)
}
if (input.matchType) {
params.push(String(input.matchType).trim())
clauses.push(`match_type = $${params.length}`)
}
const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : ''
const pageParams = [...params, pageSize, (page - 1) * pageSize]
const [countResult, rows] = await Promise.all([
query<{ total: number }>(
`SELECT COUNT(*)::int AS total FROM internal_sku_mappings ${where}`,
params,
),
query<InternalSkuMappingRow>(
`SELECT id, provider, shop_id, match_type, match_value, internal_sku,
priority, enabled, source, note, updated_at
FROM internal_sku_mappings
${where}
ORDER BY enabled DESC, priority ASC, id DESC
LIMIT $${pageParams.length - 1} OFFSET $${pageParams.length}`,
pageParams,
),
])
return {
items: rows.rows.map((row) => ({
...row,
id: Number(row.id),
priority: Number(row.priority),
})),
total: Number(countResult.rows[0]?.total || 0),
page,
pageSize,
}
}
export async function deleteInternalSkuMapping(mappingId: number): Promise<boolean> {
const id = Math.trunc(Number(mappingId) || 0)
if (id <= 0) return false
const result = await query(`DELETE FROM internal_sku_mappings WHERE id = $1`, [id])
return (result.rowCount || 0) > 0
}
/**
* 订单项级内部 SKU 补全:
* - 明确的 skuNick/outSkuSn/skuCode 已有中文 → 不查库;
* - 否则先查 internal_sku_mappings,避免中文长标题抢占内部 SKU;
* - 没有映射时才由调用方回退中文标题。
*/
export async function resolveInternalSkuForOrderItem(input: {
provider?: string | null
shopId?: string | null
spec?: Record<string, unknown> | null
skuCode?: unknown
skuName?: unknown
}): Promise<{ internalSku: string; source: string; mappingId: number } | null> {
const spec = input.spec && typeof input.spec === 'object' ? input.spec : {}
const directCandidates = [spec.skuNick, spec.outSkuSn, input.skuCode]
.map(normalizeInternalSkuMappingValue)
.filter(Boolean)
if (directCandidates.some(containsCjk)) return null
const mapping = await resolveInternalSkuMapping({
provider: input.provider ?? null,
shopId: input.shopId ?? null,
candidates: [
{ matchType: 'sku_nick', value: spec.skuNick },
{ matchType: 'out_sku_sn', value: spec.outSkuSn },
{ matchType: 'sku_code', value: input.skuCode },
{ matchType: 'sku_name', value: input.skuName },
],
})
if (!mapping) return null
return {
internalSku: canonicalizeInternalSku(mapping.internalSku),
source: mapping.source,
mappingId: mapping.id,
}
}